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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include<stdio.h>
#include<string.h>
char rightToLeft(char ch){
if(ch==')')return '(';
else if(ch==']')return '[';
else if(ch=='}')return '{';
else return '0';
}
int correspondingFlag(char ch){
if(ch==')'||ch=='(')return 1;
else if(ch=='['||ch==']')return 2;
else if(ch=='{'||ch=='}')return 3;
else return 0;
}
int main(){
char str[55];
char sta[55]={0};
int index[55]={0};
int flag[4]={0};a
int top=0;
scanf("%s",str);
int len=strlen(str);
for(int i=0;i<len;++i){
if(str[i]=='('||str[i]=='['||str[i]=='{'){//左括号入栈
sta[++top]=str[i];
index[top]=i;
}
else if(str[i]==')'||str[i]==']'||str[i]=='}'){//右括号
if(top==0||sta[top]!=rightToLeft(str[i])){//未匹配到对应左括号
sta[++top]=str[i];
index[top]=i;
}
else{//匹配到对应左括号
top--;//栈顶弹出
}
}
}
for(;top>0;top--){
flag[correspondingFlag(sta[top])]++;
}
if(flag[1]||flag[2]||flag[3]){
for(int i=1;i<4;++i){
while(flag[i]--)printf("%d,",i);
}
}
else printf("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
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
#include<stdio.h>
#include<ctype.h>
#include<string.h>
struct Stack{
char element[1000];
int cnt;
}postfix,tem;
void push(struct Stack *sta,char ch){
sta->element[++sta->cnt]=ch;
};
_Bool isempty(struct Stack sta){
return sta.cnt==0;
}
char pop(struct Stack *sta){
return sta->element[sta->cnt--];
};
char top(struct Stack sta){
return sta.element[sta.cnt];
};
_Bool higherthan(char a,char b){
return (a=='*'||a=='/')||(b=='+'||b=='-');
}
double calculate(double a,char op,double b){
if(op=='*')return a*b;
else if(op=='/')return a/b;
else if(op=='+')return a+b;
else if(op=='-')return a-b;
else return 0;
}
int main(){
char str[1000];
scanf("%s",str);
int len=strlen(str);
for(int i=0;i<len;++i){
if(isdigit(str[i])){
push(&postfix,str[i]);
}
else if(str[i]=='('){
push(&tem,'(');
}
else if(str[i]==')'){
while(isempty(tem)==0&&top(tem)!='('){
push(&postfix,pop(&tem));
}
pop(&tem);
}
else{
while(isempty(tem)==0&&top(tem)!='('&&higherthan(top(tem),str[i])){
push(&postfix,pop(&tem));
}
push(&tem,str[i]);
}
}
while(isempty(tem)==0){
push(&postfix,pop(&tem));
}
double sta[10000];
int top=0;
for(int i=1;i<=postfix.cnt;++i){
if(isdigit(postfix.element[i])){
sta[++top]=postfix.element[i]-'0';
}
else {
double b=sta[top--];
double a=sta[top--];
sta[++top]=calculate(a,postfix.element[i],b);
}
}
printf("%.2f\n",sta[top]);
for(int i=1;i<=postfix.cnt;++i){
printf("%c ",postfix.element[i]);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include<stdio.h>
int main(){
int num,cnt=0;
int ans[10000]={0};
while(scanf("%d,",&num)!=EOF){
ans[++cnt]=num;
}
for(int i=0;i<cnt;++i){
if(ans[i+1]!=ans[cnt-i]){
printf("No\n");
return 0;
}
}
printf("Yes\n");
return 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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include<stdio.h>
#include<malloc.h>
struct Node{
int value;
struct Node* child[2];
};
void insert(struct Node *now,int value){
int pos=now->value<value;
if(now->child[pos]==NULL){
now->child[pos]=(struct Node*)malloc(sizeof(struct Node));
now->child[pos]->value=value;
now->child[pos]->child[0]=now->child[pos]->child[1]=NULL;
}
else{
insert(now->child[pos],value);
}
}
int printByDepth(struct Node* now,int nowDepth,int depth){
if(nowDepth==depth){
printf("%d,",now->value);
return 1;
}
else{
int fla1=0,fla2=0;
if(now->child[0]!=NULL)fla1=printByDepth(now->child[0],nowDepth+1,depth);
if(now->child[1]!=NULL)fla2=printByDepth(now->child[1],nowDepth+1,depth);
return fla1||fla2;
}
}
void destroy(struct Node* now){
if(now->child[0]!=NULL)destroy(now->child[0]);
if(now->child[1]!=NULL)destroy(now->child[1]);
free(now);
}
int main(){
int n,depth;
struct Node* root=(struct Node*)malloc(sizeof(struct Node));
root->child[0]=root->child[1]=NULL;
scanf("%d%d,",&n,&(root->value));
for(int i=1,value;i<n;++i){
scanf("%d,",&value);
insert(root,value);
}
scanf("%d",&depth);
if(!printByDepth(root,1,depth))printf("-1");
destroy(root);
return 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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
#include<stdio.h>
#include<malloc.h>
struct Node{
int value;
struct Node* child[2];
};
void insert(struct Node *now,int value){
int pos=now->value<value;
if(now->child[pos]==NULL){
now->child[pos]=(struct Node*)malloc(sizeof(struct Node));
now->child[pos]->value=value;
now->child[pos]->child[0]=now->child[pos]->child[1]=NULL;
}
else{
insert(now->child[pos],value);
}
}
int printByDepth(struct Node* now,int nowDepth,int depth){
if(nowDepth==depth){
printf("%d,",now->value);
return 1;
}
else{
int fla1=0,fla2=0;
if(now->child[0]!=NULL)fla1=printByDepth(now->child[0],nowDepth+1,depth);
if(now->child[1]!=NULL)fla2=printByDepth(now->child[1],nowDepth+1,depth);
return fla1||fla2;
}
}
void destroy(struct Node* now){
if(now->child[0]!=NULL)destroy(now->child[0]);
if(now->child[1]!=NULL)destroy(now->child[1]);
free(now);
}
int main(){
int n,depth;
struct Node* root=(struct Node*)malloc(sizeof(struct Node));
root->child[0]=root->child[1]=NULL;
scanf("%d%d,",&n,&(root->value));
for(int i=1,value;i<n;++i){
scanf("%d,",&value);
insert(root,value);
}
scanf("%d",&depth);
if(!printByDepth(root,1,depth))printf("-1");
destroy(root);
return 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
29
30
31
32
33
34
35
36
37
38
39
40
#include<stdio.h>
#include<malloc.h>
struct Node{
int value;
struct Node* child[2];
};
void insert(struct Node *now,int value){
int pos=now->value<value;
if(now->child[pos]==NULL){
now->child[pos]=(struct Node*)malloc(sizeof(struct Node));
now->child[pos]->value=value;
now->child[pos]->child[0]=now->child[pos]->child[1]=NULL;
}
else{
insert(now->child[pos],value);
}
}
void destroy(struct Node* now){
if(now->child[0]!=NULL)destroy(now->child[0]);
if(now->child[1]!=NULL)destroy(now->child[1]);
free(now);
}
void preOrderTransverse(struct Node* now){
printf("%d,",now->value);
if(now->child[0]!=NULL)preOrderTransverse(now->child[0]);
if(now->child[1]!=NULL)preOrderTransverse(now->child[1]);
}
int main(){
struct Node* root=(struct Node*)malloc(sizeof(struct Node));
root->child[0]=root->child[1]=NULL;
scanf("%d,",&(root->value));
int value;
while(scanf("%d,",&value)!=EOF){
insert(root,value);
}
preOrderTransverse(root);
destroy(root);
return 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
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
#include<stdio.h>
#include<malloc.h>
struct Node{
int value;
int height;
struct Node* child[2];
};
int Height(struct Node* now){
return now==NULL?0:now->height;
}
int max(const int a,const int b){
return a>b?a:b;
}
void freshHeight(struct Node* now){
now->height=1+max(Height(now->child[0]),Height(now->child[1]));
}
void rotate(struct Node* parent,struct Node* now,int pos,int direction){
struct Node *newroot=now->child[!direction];
if(parent!=NULL)parent->child[pos]=newroot;
now->child[!direction]=newroot->child[direction];
newroot->child[direction]=now;
freshHeight(now);
freshHeight(newroot);
if(parent!=NULL)freshHeight(parent);
}
int checkBalance(struct Node* now,int *flag,int *twice){
if(Height(now->child[0])-Height(now->child[1])==2){
*flag=0;
}
else if(Height(now->child[1])-Height(now->child[0])==2){
*flag=1;
}
else return 0;
*twice=Height(now->child[*flag]->child[*flag])<Height(now->child[*flag]->child[!(*flag)]);
return 1;
}
void reBalance(struct Node* parent,struct Node* now,int pos){
int rotateflag,twiceflag,flag;
flag=checkBalance(now,&rotateflag,&twiceflag);
if(flag){
if(twiceflag)rotate(now,now->child[rotateflag],rotateflag,rotateflag);
rotate(parent,now,pos,!rotateflag);
}
}
void insert(struct Node *now,int value){
int pos=now->value<value;
if(now->child[pos]==NULL){
now->child[pos]=(struct Node*)malloc(sizeof(struct Node));
now->child[pos]->value=value;
now->child[pos]->child[0]=now->child[pos]->child[1]=NULL;
now->child[pos]->height=1;
}
else{
insert(now->child[pos],value);
reBalance(now,now->child[pos],pos);
}
freshHeight(now);
}
void destroy(struct Node* now){
if(now->child[0]!=NULL)destroy(now->child[0]);
if(now->child[1]!=NULL)destroy(now->child[1]);
free(now);
}
void preOrderTransverse(struct Node* now){
printf("%d,",now->value);
if(now->child[0]!=NULL)preOrderTransverse(now->child[0]);
if(now->child[1]!=NULL)preOrderTransverse(now->child[1]);
}
int main(){
struct Node* root=(struct Node*)malloc(sizeof(struct Node));
root->child[0]=root->child[1]=NULL;
root->height=1;
scanf("%d,",&(root->value));
int value;
while(scanf("%d,",&value)!=EOF){
insert(root,value);
}
preOrderTransverse(root);
destroy(root);
return 0;
}
//这个代码其实有漏洞,请你理解后找出来

十月October

之前有朋友问我算法问题,我才发现他已经慢慢学到kruskal了
kruskal本身不难,他之前也问了我很多语法问题,这似乎是第一次问算法相关
但是我却被他代码中浓浓的工程风格给小小震撼了一下,命名无可挑剔,封装恰到好处,简直不像是算法处女作
本来命名也就多费点精力的事,不能算多难,但我上大学后见到的99%的代码都严重缺乏这样的规范
更何况他是在尚未学完kruskal的前置知识的时候就主动去摸索算法流程,能够自己形成清晰的想法并非常准确地描述出来
尽管他的想法最终被我推翻,但也让我有了一些思考,更让我重新拾起高中信竞时期跟队友激情讨论算法过程的快感

九月September

小小总结一波小学期小组的经历

一开始分组时脑中一片空白,不断跟学姐打探小学期的各种情况,当时学姐一句“你们这个小学期,除了要用文件读取就没啥啦”直接让我舒服了

后来选完航空售票系统的问题,我们果断组织开展组员大学习,组长与gfy同志亲自部署、亲自指挥,安排其余组员于菜鸟教程上进行C艹先进技术的学习,坚决落实组长(也就是我)的各项要求,并于两日内超额完成学习任务(指本来也没指望学会多少)

开始设计了个基于页面栈思想的main函数,把大系统分解成了一个个小页面,在structure里面确定页面间的关系逻辑,后面十几天这个框架就基本没啥改动了

框架出来后,很快啊,我立马给我嗷嗷待哺的组员喂养了一坨任务,收到任务的那一刻,每个人脸上都洋溢着喜悦,并表示自己还能再干更多!(资本家泪目)

在组员间游走的时光,是我这个小学期最为放松且满足的日子,所有的问题好像都不是问题,所有的bug都露出它温顺的一面,验收的日子看起来是那么遥远,实现自己的想法看起来是那么简单,出于一种对未知的挑战,gfy同学也在这段时间承担下了给用户发送邮箱验证码的任务

好景不长,命令行界面的页面布局始终困扰着我,无论怎么布局,用户的输入始终只能在固定的地点,代码也因为要检查用户输入而变得像老太太的裹脚布–又臭又长。失去了优美,代码还有什么意义!我的关于图形界面的想法蠢蠢欲动

星期六是跌宕的一天,这天组员们寻得了一片喘息的空间,我为了不妨碍原有框架,新建了一个airTicketSystemGUI文件夹,将我并不成熟的想法倾注其中,在此之前,我已然决定,若一个上午无法形成完整框架,就放弃这一全新的尝试

果然天不遂人愿,直到中午我都没有完成既定目标,页面要想转型成图形,块的概念是必不可少的,我急于借鉴HTML的设计理念,试图实现块中有块的效果,却在继承关系上栽了个大跟头

大跃进的失败已然固定,跟别人小小抱怨后,我迅速从airTicketSystemGUI文件夹中抽身,及时止损,不让不成功的转型过多影响原有项目进度

但心中不甘在所难免,一上午的摸索也让我学到了不少新知识,我决定将一部分图形功能加入原有界面,于是Button类诞生了

这个类承载了我上午未尽的想法,也丢弃了其中晦涩的指针部分(刚看完c++ primer的我实在庆幸这一决定,不然我一定会遇到带指针类拷贝时自动浅拷贝的问题),我在实现欢迎界面的过程中逐步完善了这个类的其他函数以更方便地获取鼠标点击,与lcj一起完成了诸多必不可少的函数定义

这一步走得实在艰辛,那几天,游刃有余的感觉荡然无存,取而代之的是无尽的bug与错误信息,组员也因缺少任务而无法被充分调动,我在他们早上一起来就催我发布任务的那一刻觉得自己就像游戏里的npc,只是这个npc并没有固定的任务发布流程,他也暂时陷入了僵局

后来不知调掉了多少bug,百度了多少信息,终于在大约周日晚上的时候把原有进度中的所有页面全面升级成了支持鼠标点击的界面,而也大约在这时,gfy带着捷报回寝,他利用smtp协议和telnet协议成功完成了验证码发送功能,并在我的邮箱里成功尝试,我直呼好事成双,却不知我的噩梦才刚刚开始

程序中的bug解决了,团队的问题却逐渐浮现,由于时间过紧学的太快,奈何我拼命解释,那些刚学C艹的组员在理解我的代码上始终有点吃力,我只能退而求其次,自己承担起剩下页面的设计,将一些小巧轻便的函数分给组员去做

又在这时,新的问题出现,我发现上星期交给组员的各种函数的实现实在太不符合我的一贯码风,前期未确立代码规范的弊端也在此时显现,我花了较多时间改掉了其他人的代码,自然而然地用到了太多高级操作,也给读懂代码的门槛提高了不少,再次加大了组员的跟进难度,不过cyq同志热情不减,领下了忘记密码界面的全部设计工作

就在我给所有代码大换血后,还没等挨个测试,我就又迸出了改进Button类的想法,偏偏这个想法还很符合实际,我于是开始了框架的第二次大改

这次大改的代码量比第一次只多不少,不到两天的苦战,当我再次把代码push进我们的仓库时,git上显示page.cpp的一千多行代码改动了67%

第二次大改后,离项目验收已经只剩1天时间,bug多到找不完,也深到de不了,页面已完成设计,背后的逻辑却尚未跟上,我将所有花里胡哨的想法通通抛弃,把与用户的交互做了最大简化,顺便将cyq完成的忘记密码界面做了些许调整,规避了一切可能的出现在交互层的bug,让自己沉下心来修复满目疮痍的后端

中间一些小插曲更是让我有点崩溃,有没有人告诉我为什么这么多组用qt啊!!!还带数据库的那种!!!

幸好,后端所需技术仍然在我从高中遗留下来的知识范围内,模板的加入也让后端代码变得优美无比,接下来发动所有组员的bug调试工作也进行得很快,有时候后端一个bug的修复,能顺带着让前端的无数错误输出回到正轨,对代码模块化的追求终究没有白费,甚至在验收前的那一刻,我还往这个庞然大物里添加了一个重要功能

至此,在验收结束的星期五,这个一波三折的故事就此告一段落,我们的代码或许不是最好,但这段经历在我这里最为刻骨铭心

附带我们组的gitee仓库,已开源
https://gitee.com/Ajsoabk/primary-school-homework/tree/master

10.17(Block Chain)

It’s worth to know the history of failure

10.12(开源协议)

GNU GPL(GNU General Public License)协议,传播自由,可选收费

BSD(Berkeley Software Distribution)协议,允许销售,无需开源

Apache许可证协议 ,需要保留源代码的协议、商标、专利声明及其他原作者声明的内容信息

MIT(Massachusetts Institute of Technology)协议,只要保留原作者的许可信息,最宽松

GNU LGPL(GNU Lesser…),必须允许被引用

如何选择开源协议

10.2(以太坊、密码学)

哈希不可逆,可以防止量子计算机的破解

proof of work -> proof of stack(权益证明)

Patricia tree/Patricia trie(压缩字典树)

Merkle Patricia tree

Modified MPT是以太坊运用的数据结构,甚至有可持久化?

RLP,极简的序列化方法

protobuf是一种序列化库

以太坊可以看成交易驱动的状态机

GHOST协议

叔叔节点祖宗六代

LiteCoin,基于Scrypt的mining puzzle,对轻节点不友好

以太坊的挖矿算法要求16M的cache和1G的DAG

AltCoin Infanticide

权益证明是闭环

nothing at stake(无利害关系)

Casper the Friendly Finality Gadget(FFG)

10.1(区块链)

序列到期可撤销合约(RSMC)解决了比特币单向流动问题

哈希时间锁定合约(HTLC)解决了比特币跨节点传递的问题

哈希地址 中文名
P2PKH 向公钥哈希支付 以1打头 只需要提供公钥和私钥签名
P2SH 向脚本哈希支付 以3打头

比特币的 P2SH 机制 - 知乎 (zhihu.com)

比特币区块链(八) | 比特币中的脚本系统 - 知乎 (zhihu.com)

merkle proof 证明某个交易是否被写入区块

9.29(区块链)

ICO(Initial Coin Offering),首次代币募集

9.27(信号与系统)

记忆性 $$(h[n]=K\delta[n])$$

因果性 $$(h[n]=0\ when\ n<0)$$

可逆性

$$(for\ h[n],there\ exists\ h^{-1}[n]\ that\ satisfies\ h[n]*h^{-1}=\delta [n])$$

稳定性$(\Sigma h[n]<+\infin)$

时不变性$(h_k[n]=h[n-k])$

可加性$(h[n]\cdot x_1[n]+h[n]\cdot x_2[n]=h[n]\cdot(x_1[n]+x_2[n]))$

比例性$(h[n]\cdot \alpha x[n]=\alpha h[n] \cdot x[n])$

9.24(区块链)

哈希指针

转账需给出签名过的转出者的公钥,并指向上一个交易以及币的来源

程序设计语言原理

语言在正交性与简单性间取舍

抽象的概念

过程抽象(如模板)与数据抽象(如STL)

可靠性

类型检测与异常处理

语言的各方面直观指标

  1. 程序员的学习代价
  2. 程序员的编写代价
  3. 程序的编译时间(优化技术)
  4. 程序执行的速度
  5. 程序运行所需条件(硬件设备或软件系统)
  6. 程序的可靠性
  7. 程序维护代价

语言的类别

命令式,函数式,面向对象语言,可视化语言,标记语言,特殊用途语言

冯诺依曼瓶颈

指令从存储器到处理器的速度决定着这台计算机的速度

每天都有新体验