liuchuo – 第115页 – 我不管，反正我最萌～

L1-037. A除以B 团体程序设计天梯赛GPLT

真的是简单题哈 —— 给定两个绝对值不超过100的整数A和B，要求你按照“A/B=商”的格式输出结果。

输入格式：
输入在第一行给出两个整数A和B（-100 <= A, B, <= 100），数字间以空格分隔。

输出格式：
在一行中输出结果：如果分母是正数，则输出“A/B=商”；如果分母是负数，则要用括号把分母括起来输出；如果分母为零，则输出的商应为“Error”。输出的商应保留小数点后2位。

输入样例1：
-1 2
输出样例1：
-1/2=-0.50
输入样例2：
1 -3
输出样例2：
1/(-3)=-0.33
输入样例3：
5 0
输出样例3：
5/0=Error

分析：如果b小于0就左右加上括号，如果b=0就要输出计算结果为Error，其余情况就输出a/b的保留两位小数的结果～

#include <cstdio>
using namespace std;
int main() {
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d/", a);
    if (b >= 0)
        printf("%d=", b);
    else
        printf("(%d)=", b);
    if (b == 0)
        printf("Error");
    else
        printf("%.2f", a * 1.0 / b);
    return 0;
}

#include <cstdio>

using namespace std;

int main() {

int a, b;

scanf("%d%d", &a, &b);

printf("%d/", a);

if (b >= 0)

printf("%d=", b);

else

printf("(%d)=", b);

if (b == 0)

printf("Error");

else

printf("%.2f", a * 1.0 / b);

return 0;

}

L1-035. 情人节团体程序设计天梯赛GPLT

以上是朋友圈中一奇葩贴：“2月14情人节了，我决定造福大家。第2个赞和第14个赞的，我介绍你俩认识…………咱三吃饭…你俩请…”。现给出此贴下点赞的朋友名单，请你找出那两位要请客的倒霉蛋。

输入格式：
输入按照点赞的先后顺序给出不知道多少个点赞的人名，每个人名占一行，为不超过10个英文字母的非空单词，以回车结束。一个英文句点“.”标志输入的结束，这个符号不算在点赞名单里。

输出格式：
根据点赞情况在一行中输出结论：若存在第2个人A和第14个人B，则输出“A and B are inviting you to dinner…”；若只有A没有B，则输出“A is the only one for you…”；若连A都没有，则输出“Momo… No one is for you …”。

输入样例1：
GaoXZh
Magi
Einst
Quark
LaoLao
FatMouse
ZhaShen
fantacy
latesum
SenSen
QuanQuan
whatever
whenever
Potaty
hahaha
.
输出样例1：
Magi and Potaty are inviting you to dinner…
输入样例2：
LaoLao
FatMouse
whoever
.
输出样例2：
FatMouse is the only one for you…
输入样例3：
LaoLao
.
输出样例3：
Momo… No one is for you …

分析：接收输入，当输入为”.”的时候退出循环～每次接收一个输入就将cnt++，如果当前cnt==2或者==4就将结果保存到string a或者string b中，最后根据cnt不同的值输出不同的结果～

#include <iostream>
using namespace std;
int main() {
    string a, b, str;
    int cnt = 0;
    while(cin >> str) {
        if (str == ".") break;
        cnt++;
        if (cnt == 2) a = str;
        if (cnt == 14) b = str;
    }
    if (cnt >= 14)
        cout << a << " and " << b << " are inviting you to dinner...";
    else if (cnt <= 1)
        cout << "Momo... No one is for you ...";
    else
        cout << a << " is the only one for you...";
    return 0;
}

#include <iostream>

using namespace std;

int main() {

string a, b, str;

int cnt = 0;

while(cin >> str) {

if (str == ".") break;

cnt++;

if (cnt == 2) a = str;

if (cnt == 14) b = str;

}

if (cnt >= 14)

cout << a << " and " << b << " are inviting you to dinner...";

else if (cnt <= 1)

cout << "Momo... No one is for you ...";

else

cout << a << " is the only one for you...";

return 0;

}

L1-034. 点赞团体程序设计天梯赛GPLT

微博上有个“点赞”功能，你可以为你喜欢的博文点个赞表示支持。每篇博文都有一些刻画其特性的标签，而你点赞的博文的类型，也间接刻画了你的特性。本题就要求你写个程序，通过统计一个人点赞的纪录，分析这个人的特性。

输入格式：
输入在第一行给出一个正整数N（<=1000），是该用户点赞的博文数量。随后N行，每行给出一篇被其点赞的博文的特性描述，格式为“K F1 … FK”，其中 1<=K<=10，Fi（i=1, …, K）是特性标签的编号，我们将所有特性标签从1到1000编号。数字间以空格分隔。

输出格式：
统计所有被点赞的博文中最常出现的那个特性标签，在一行中输出它的编号和出现次数，数字间隔1个空格。如果有并列，则输出编号最大的那个。

输入样例：
4
3 889 233 2
5 100 3 233 2 73
4 3 73 889 2
2 233 123
输出样例：
233 3

分析：使用arr[1001]存储每个性格标签出现的次数，遍历arr数组，找到出现次数最多的保存为maxValue，并保存其下标为maxIndex～
maxIndex就是出现次数最多的特性标签，maxValue就是该特性标签出现的次数～

#include <cstdio>
using namespace std;
int main() {
    int n, k, num, maxIndex = 0, maxValue = 0;
    scanf("%d", &n);
    int arr[1001] = {0};
    for (int i = 0; i < n; i++) {
        scanf("%d", &k);
        for (int j = 0; j < k; j++) {
            scanf("%d", &num);
            arr[num]++;
        }
    }
    for (int i = 0; i < 1001; i++) {
        if (arr[i] >= maxValue) {
            maxValue = arr[i];
            maxIndex = i;
        }
    }
    printf("%d %d", maxIndex, maxValue);
    return 0;
}

#include <cstdio>

using namespace std;

int main() {

int n, k, num, maxIndex = 0, maxValue = 0;

scanf("%d", &n);

int arr[1001] = {0};

for (int i = 0; i < n; i++) {

scanf("%d", &k);

for (int j = 0; j < k; j++) {

scanf("%d", &num);

arr[num]++;

}

for (int i = 0; i < 1001; i++) {

if (arr[i] >= maxValue) {

maxValue = arr[i];

maxIndex = i;

}

printf("%d %d", maxIndex, maxValue);

return 0;

}

CCCC-GPLT L1-033. 出生年天梯赛

以上是新浪微博中一奇葩贴：“我出生于1988年，直到25岁才遇到4个数字都不相同的年份。”也就是说，直到2013年才达到“4个数字都不相同”的要求。本题请你根据要求，自动填充“我出生于y年，直到x岁才遇到n个数字都不相同的年份”这句话。

输入格式：
输入在一行中给出出生年份y和目标年份中不同数字的个数n，其中y在[1, 3000]之间，n可以是2、或3、或4。注意不足4位的年份要在前面补零，例如公元1年被认为是0001年，有2个不同的数字0和1。

输出格式：
根据输入，输出x和能达到要求的年份。数字间以1个空格分隔，行首尾不得有多余空格。年份要按4位输出。注意：所谓“n个数字都不相同”是指不同的数字正好是n个。如“2013”被视为满足“4位数字都不同”的条件，但不被视为满足2位或3位数字不同的条件。

输入样例1：
1988 4
输出样例1：
25 2013
输入样例2：
1 2
输出样例2：
0 0001

分析：对于从y开始一直到3012（因为就算最大值3000，一直检验到3012也满足题意了～后面的就没必要了～），将它的每一位的数字放入集合s里面，因为集合是不允许重复数字的，所以集合s的大小就是当前这个数字的不重复数字的个数～当集合s的大小和n相等时，说明满足题意，输出就好啦～

#include <cstdio>
#include <set>
using namespace std;
int main() {
    int y, n;
    scanf("%d%d", &y, &n);
    for (int i = y; i <= 3012; i++) {
        set<int> s;
        int num = i;
        for (int j = 0; j < 4; j++) {
            s.insert(num % 10);
            num /= 10;
        }
        if (s.size() == n) {
            printf("%d %04d", i - y, i);
            break;
        }
    }
    return 0;
}

#include <cstdio>

#include <set>

using namespace std;

int main() {

int y, n;

scanf("%d%d", &y, &n);

for (int i = y; i <= 3012; i++) {

set<int> s;

int num = i;

for (int j = 0; j < 4; j++) {

s.insert(num % 10);

num /= 10;

}

if (s.size() == n) {

printf("%d %04d", i - y, i);

break;

}

return 0;

}

《黑客与画家》读书笔记

2017-03-17 15:33:36

这时，“黑客”这个词不仅是第一流能力的象征，还包含着求解问题过程中产生的精神愉悦或享受。也就是说，从一开始，黑客就是有精神追求的。自由软件基金会创始人理查德·斯托尔曼说：“出于兴趣而解决某个难题，不管它有没有用，这就是黑客。”

2017-03-17 15:33:52

根据理查德·斯托尔曼的说法，黑客行为必须包含三个特点：好玩、高智商、探索精神。

2017-03-17 15:37:34

为了澄清“黑客”这个概念，他们提出只有传统意义上的黑客才能被称为hacker，而那些恶意入侵计算机系统的人应该被称为cracker（入侵者）。这个观点已经在程序员社区中得到普通认同。

2017-03-17 15:39:07

Hackers and Painters这个书名就是在提示应该把黑客与画家当作同一种人看待。和画家一样，黑客只是怀有一门特殊手艺、有创造天赋的普通人。这个书名还有另一层含义，即编程是一种艺术创作，黑客就是艺术家，开发软件与画家作画、雕塑家雕刻、建筑师设计房屋并没有本质不同。

2017-03-17 16:34:59

在一个人产生良知之前，折磨就是一种娱乐。

2017-03-17 16:35:48

但是我认为，孩子们欺负书呆子的主要原因也与追求“受欢迎”的心理有关。怎样才能让自己更受欢迎？个人魅力只是很小的一方面，你应该更多地考虑如何结盟。秘诀就是不停地设法使自己与其他受欢迎的人变得关系更密切。没有什么比一个共同的敌人更能使得人们团结起来了。

2017-03-17 16:37:55

如果说其中还有一丝安慰，那就是书呆子不妨记住，这种虐待不是针对个人的。一群孩子成群结伙地欺负你，那并不是因为你做错了什么，而是因为这一伙人需要找一件事情一起干，这就好像一群人成群结伙地去打猎一样。他们实际上并不恨你，他们只是需要一个共同的目标。

2017-03-19 15:55:51

我认为，真实世界的关键并非在于它是由成年人组成的，而在于它的庞大规模使得你做的每件事都能产生真正意义上的效果。学校、监狱、上流社会的女士午餐会，都做不到这一点。这些场合的成员都好像关在封闭的泡沫之中，所作所为只对泡沫内部有影响，对外部没有影响。那么很自然地，这些场合就会产生野蛮的做法。因为它们不具备实际功能，所以也就无所谓采用的形式^。

2017-03-19 15:56:50

「约翰·纳什（John Nash，1928—），美国著名数学家，因其对博弈论的突出贡献而获得1994年的诺贝尔经济学奖。纳什从小性格孤僻，不合群，读大学期间以行为古怪而闻名，30岁时就患上了严重的精神分裂症。电影《美丽心灵》讲述的就是他的故事。——译者注」

2017-03-19 15:57:41

因为我在这个世界中过得并不好，我觉得一定是自己什么地方做错了。我没有意识到，作为书呆子，我不适应周围环境，某种程度上正说明我领先了一步。书呆子已经在思考的东西，正是真实世界看重的东西。他们与别人不一样，不把所有时间用来玩一种耗尽全力但又亳无意义的游戏。

2017-03-19 16:34:07

对于书呆子来说，意识到学校并非全部的人生，也是很重要的事情。学校是一个很奇怪的、人为设计出来的体系，一半像是无菌室，一半像是野蛮洪荒之地。它就像人生一样，里面无所不包，但又不是事物的真实样子。它只是一个暂时的过程，只要你向前看，你就能超越它，哪怕现在你还是身处其中。

2017-03-19 16:36:25

「在英语中，“建筑师”（architect）和“架构师”（architect）是同一个词，所以这里用的是双关语，意思是优秀程序员不仅负责建造，还负责架构。后一句中的“建筑学”（architecture）也是这种双关用法，同时指“架构学”（architecture）。一译者注」

2017-03-19 16:39:46

首先，科学研究必须具有原创性。写过博士论文的人都知道，确保自己正在开垦新领地的方法，就是去找那些没有人要的土地。

2017-03-19 16:41:05

那么，为什么大学和实验室还把论文数量作为考核黑客工作的指标呢？这种事情其实在日常生活中普遍存在，比如，我们使用简单的标准化测试考核学生的“学术能力倾向”（scholastic aptitude），再比如，我们使用代码的行数考核程序员的工作效率。这样的考核容易实施，而容易实施的考核总是首先被采用。

2017-03-20 14:41:40

我对待代码的认真程度远远超过我对待其他事情，如果我以这种态度对待日常生活的每件事，那么我就够资格找心理医生开处方药了。看到代码前面的缩进乱七八糟，或者看到丑陋的变量名，都会把我逼疯的。

2017-03-20 14:42:06

黑客就像画家，工作起来是有心理周期的。有时候，你有了一个令人兴奋的新项目，你会愿意为它一天工作16个小时。等过了这一阵，你又会觉得百无聊赖，对所有事情都提不起兴趣。

2017-03-20 15:42:58

这时你要明白，自由思考比畅所欲言更重要。如果你感到一定要跟那些人辩个明自，绝不咽下这口气，一定要把话说清楚，结果很可能是从此你再也无法自由理性地思考了。我认为这样傲不可取，更好的方法是在思想和言论之间划一条明确的界线。在心里无所不想，但是不一定要说出来。我就鼓励自己在心里默默思考那些最无法无天的想法。你的思想是一个地下组织，绝不要把那里发生的事情一股脑说给外人听。

2017-03-20 15:43:38

因为弥尔顿是一个喜欢争论、好打嘴仗的人，而当时罗马教廷的宗教裁判所非常强势，所以沃顿爵士才会这样建议他。需要记住的是，弥尔顿的时代与我们的时代并没有本质不同。每个时代都有自己的忌讳，如果你触犯它们，就算没有坐牢，至少也会为自己惹来麻烦，干扰了正常生活。

2017-03-20 15:44:39

所以，如果可能的话，你最好找一些信得过的知己，只与他们畅所欲言、无所不谈。这样不仅可以获得新观点，还可以用来选择朋友。能够一起谈论“异端邪说”并且不会因此气急败坏的人，就是你最应该认识的朋友。

2017-03-20 20:28:05

互联网应用程序能够同时被多人使用，所以非常适合团队协作性的工作。大多数用户现在还不了解软件协同办公，否则估计他们会强烈要求大部分应用程序都具备这个功能。举例来说，允许两个用户同时编辑一个文档是一项很有用的功能。

2017-03-20 22:30:38

投资者和分析家会问，你们对未来有何计划。真实的回答是，我们没有任何计划。我们有改进的想法，但是如果我们想到应该怎么改进，就已经把它实现了。接下来六个月我们要做什么？所有能想到的最佳改进。我不知道自己是否有胆量公开这么说，但这是实话。计划这个词，只是将构思束之高阁的另一种表达方式。只要想到好的构思，我们就立刻着手实现。

继续阅读《黑客与画家》读书笔记

PAT 1130. Infix Expression (25)-甲级

Given a syntax tree (binary), you are supposed to output the corresponding infix expression, with parentheses reflecting the precedences of the operators.

Input Specification:
Each input file contains one test case. For each case, the first line gives a positive integer N ( <= 20 ) which is the total number of nodes in the syntax tree. Then N lines follow, each gives the information of a node (the i-th line corresponds to the i-th node) in the format:
data left_child right_child
where data is a string of no more than 10 characters, left_child and right_child are the indices of this node’s left and right children, respectively. The nodes are indexed from 1 to N. The NULL link is represented by -1. The figures 1 and 2 correspond to the samples 1 and 2, respectively.

Output Specification:
For each case, print in a line the infix expression, with parentheses reflecting the precedences of the operators. Note that there must be no extra parentheses for the final expression, as is shown by the samples. There must be no space between any symbols.
Sample Input 1:
8
* 8 7
a -1 -1
* 4 1
+ 2 5
b -1 -1
d -1 -1
– -1 6
c -1 -1
Sample Output 1:
(a+b)*(c*(-d))
Sample Input 2:
8
2.35 -1 -1
* 6 1
– -1 4
% 7 8
+ 2 3
a -1 -1
str -1 -1
871 -1 -1
Sample Output 2:
(a*2.35)+(-(str%871))

题目大意：给一个二叉树，输出中缀表达式，且加上括号表示运算的优先级～
分析：首先根据所有孩子结点编号寻找1～n中没有出现过的编号标记为root，即树的根结点～然后进行从root结点开始dfs～dfs递归拼接 “(” + 左子树 + 根 + 右子树 + “)”
递归有四种情况（有效的只有三种）：
1. 左右子树都空返回 “(” + 根 + “)”
2. 左空右不空返回 “(” + 根 + 右子树 + “)”
3. 左不空右空这种情况不存在
4. 左右都不空返回 “(” + 左子树 + 根 + 右子树 + “)”
最后递归返回的ans，最外层可能会被括号包起来，也可能不被包起来。要判断一下，如果被包起来，把最外层括号去掉即可～

#include <iostream>
using namespace std;
struct node {
    string data;
    int l, r;
}a[100];
string dfs(int root) {
    if(a[root].l == -1 && a[root].r == -1) return a[root].data;
    if(a[root].l == -1 && a[root].r != -1)  return "(" +  a[root].data + dfs(a[root].r) + ")";
    if(a[root].l != -1 && a[root].r != -1) return "(" +  dfs(a[root].l) + a[root].data + dfs(a[root].r) + ")";
}
int main() {
    int have[100] = {0}, n, root = 1;
    cin >> n;
    for(int i  = 1; i <= n; i++) {
        cin >> a[i].data >> a[i].l >> a[i].r;
        if(a[i].l != -1) have[a[i].l] = 1;
        if(a[i].r != -1) have[a[i].r] = 1;
    }
    while(have[root] == 1) root++;
    string ans = dfs(root);
    if(ans[0] == '(') ans = ans.substr(1,ans.size()-2);
    cout << ans;
    return 0;
}

#include <iostream>

using namespace std;

struct node {

string data;

int l, r;

}a[100];

string dfs(int root) {

if(a[root].l == -1 && a[root].r == -1) return a[root].data;

if(a[root].l == -1 && a[root].r != -1) return "(" + a[root].data + dfs(a[root].r) + ")";

if(a[root].l != -1 && a[root].r != -1) return "(" + dfs(a[root].l) + a[root].data + dfs(a[root].r) + ")";

}

int main() {

int have[100] = {0}, n, root = 1;

cin >> n;

for(int i = 1; i <= n; i++) {

cin >> a[i].data >> a[i].l >> a[i].r;

if(a[i].l != -1) have[a[i].l] = 1;

if(a[i].r != -1) have[a[i].r] = 1;

}

while(have[root] == 1) root++;

string ans = dfs(root);

if(ans[0] == '(') ans = ans.substr(1,ans.size()-2);

cout << ans;

return 0;

}