万物皆数，终身为学

腾讯实习生后台开发面试经历

2018-04-18T03:00:36+00:00

提前批：

IEG面试官是王者荣耀的后台主程，我感觉他水平还是很高的，比如：匿名内存映射以及堆分配内存是由mmap函数里的阈值来调整的；一致性哈希算法本身也存在可能分布式不一致的问题。

腾讯IEG后台开发一面

1.自我介绍

2.项目里用到Hibernate，为什么要用这个框架

3.你们为什么要把进程、文件的依赖关系映射到设备端中呢

4.下面问基础知识：什么是僵死进程？

5.什么是守护进程？

6.子进程退出会向父进程发出什么信号

7.父进程退出如何告诉子进程

8.虚拟内存和RSS的区别

9.可执行文件的存储结构

10.那栈空间是从高地址分配空间吗

11.堆空间是从低地址分配空间吗

11.1 mmap的原理

12.虚拟地址和物理地址的区别

12.SWAP分区是什么

13.cache和data

14.块又是什么呢

15.大顶端和小顶端的区别

16.网络字节是哪个字节序

17.MTU和MSS的区别

18.TCP分段和IP分片

19.TCP三次握手和四次挥手

20.为什么会有TIME_WAIT状态

21.SYN攻击是什么

22.常见的SYN防御方式

23.new和malloc的区别

24.malloc分配内存的策略

first hit best hit

24.子类继承父类，初始化顺序

25.virtual函数

26.你对未来的职业有何规划

27.那你知道常见的负载均衡算法吗

28.一致性哈希本身存在什么问题（考察学习思考能力）

29.你有什么想问我的

我们主要看在校的项目经验，但是如果没有丰富的项目的话，就看重基础和学习能力了。基础的话就是我刚刚问你的那些，学习能力就是除了你在课上学习的东西，有没有额外地学习一些东西，并且考虑自己怎么实现、提升。而且比如说我刚刚说到一致性哈希自身有什么问题，这都是需要去自主学习思考的，而不是了解概念就完了。我了解得也差不多了，那就这样吧。

    **结果** 
    凉。
    **总结** 
    王者荣耀组问了我差不多30个问题，基础面考察很广很深，当时还没来得及巩固基础，所以连虚拟地址映射都没回答清楚，所以这一面没过可以说是3月初还没开始复习。后来一个月就不断看书，刷题。基本把本科的内容复习完了，所以后续面试就很轻松。

腾讯深圳提前批现场面试 TEG后台一面

自我介绍
手写一个双向链表
双向链表增加并删除节点
谈一下你的项目吧
```
 • 略
```
数据结构和算法学的怎么样
```
 • 还行吧，经常刷题
```
10亿个元素找出最大的100个元素
```
 • 小顶堆和partition
```

你经常用的树有哪些

 • B树
 • Trie树
 • 二叉查找树
 • AVL树
 • 红黑树（了解）

B树和B+树的区别
```
 • 略
```

你看过哪些书呢

 • Unix环境高级编程
 • Unix网络编程
         ○ 卷一 socket
         ○ 卷二 ipc
 • Corejava
         ○ 卷一 基础
         ○ 卷二 进阶
 • java编程思想
 • java并发编程的艺术
 • 深入理解JVM
 • TCP/IP协议 卷一
 • Linux系统编程
 • Redis实战
 • C++ primer
 • Effective C++
 • 深入理解C++对象模型
 • STL源码剖析
 • C++ primer
 • python基础教程

你看书看的挺多的，那你代码实践怎么样呢，你给写一个简单的并发TCP服务器和客户端吧
```
• 前几天帮学姐调试的时候顺便自己写了个epoll多线程并发，所以写的也不费劲
```

那你还知道其他的并发方式吗？

• 思想：父进程fork多个子进程，迭代服务器

你看书是为了找工作看的呢，还是你出于别的原因？

• 并发是写项目需要，所以把名著的demo都跑了一遍
• java和python是自己的兴趣所在，所以相对看的更多一些
• redis是当前应用很广泛的Nosql数据库，比memcached相比有很大的优势
• 所以主要还是兴趣驱动的吧（其实就是为了找工作

简单谈谈你对redis的了解

进程通信有哪些方式呢

• 管道
• FIFO
• 消息队列
• 同步（互斥量、读写锁、条件变量、记录锁）
• 信号量
• 共享内存
• 套接字

TCP和UDP的区别

那你看过哪些开源项目的源码呢

• Snort，和项目有关（然后把运行流程说了一遍）

那我用tcpdump拦截端口号为80的数据包该怎么做呢

你还有什么要问我的？

**结果**        
过

**总结**        
现场面一面是很轻松的，因为之前IEG面过之后就狠狠复习了基础，这些问题都略显简单了。可能是这面表现很好，后续的面试就再也没有问过我基础问题了，只针对我的项目问问题了，特别是线路面试尤为明显。

腾讯深圳提前批现场面试 TEG后台二面（压力面）

1.简单介绍下在校时做过的项目

2.你们项目里的主动存储是什么意思

3.那我用单机来做和用多个OSD来做有什么区别吗

4.那你觉得你们项目里有难点吗（被鄙视

5.你们论文是不是有点水分存在的呀（被鄙视

6.这个项目测试的数据量有多大（被质疑

7.那这个项目测试的效果又怎样呢

8.这个国家自然科学基金项目好像和我们工业界并没有联系得很紧呀（再次被鄙视

9.你了解工业界常用的服务器架构吗

10.那你了解redis怎么实现可靠性和高可用性吗

11.redis做集群你了解不

12.你对你的职业规划是怎样的

13.那你平常有去查看一些源码或者学习新的框架吗

14.能实习多久

15.我对你的建议时，做科研不要太封闭了，多看看业界是怎么做的。然后自己感兴趣的东西一定要去多挖掘一下，不要浅尝辄止对吧，上去等HR面通知吧（我就是不了解才来找实习的呀…

    **结果** 
    凉。
    **总结**
    这次面试经历最不爽了...感觉是一场压力面，问项目的时候问的很细，我没有提前准备好，有些回答没来得及组织语言。然后确实后台的架构比如NginX、Tomcat本身的源码我也没有查看过，所以后续又把NginX给看了一遍。确实给我提了一些不错的建议，还是很感谢这位面试官的。

线路面试

TEG后台一面

简单的自我介绍（我都背下来了）
你们的项目只是为了收集溯源信息吗
那入侵检测用的哪种算法
还了解别的入侵检测算法吗（之前写本子调研的用CNN intrusion detection.
你承担的工作是哪些呢
整个编码过程，你觉得最难的地方在哪儿
那你有尝试进行优化，或者说是硬抗下来的吗（真的是硬抗
目前测试的效果如果，误检率多少
行吧，那简单写个小程序，逆序单链表
不错，你的优缺点是什么
还有什么想问我的吗

基础的话，我们是根据笔试成绩以及之前面试的记录来评判的，所以不会重复再问的。

**结果** 
过

**总结**
大概是之前笔试编程题AC了两道，然后之前一面反馈都还不错，所以就没有问我基础问题了。

TEG后台二面

项目
博客里的问题

还有什么想问的

 **结果** 
 过
 **总结** 
 依然没问基础问题，应该是之前有记录在的。然后面试官人很好~

TEG后台HR面

自我介绍
家是哪儿的，父母干什么的
为什么不想回成都发展
你这么年轻就要硕士毕业了，是跳级还是读书早呀
有女朋友是吧
BAT三家给你offer，你选哪家（必然你们家啊
对深圳的印象怎么样
实习时间

还有什么问题

 **结果** 
 拿到offer
 **总结** 
 没啥好说的，第6点可以提前准备一下，提一下企业文化以及个人发展空间。

Redis实现高可用性

2018-04-09T10:49:36+00:00

Redis利用主从复制机制，能够实现Redis高可用性。然而，如果Master服务器宕机，会导致整个Redis瘫痪，这种方式的高可用性较低。正常会采用多台Redis服务器构成一个集群.

在Redis中，主要存在两种方式实现Redis集群机制：

Redis Sentinel集群机制:在Redis2.X版本，往往都是通过这种方式实现Redis的高可用。redis-sentinel是在master-slave机制上加入监控机制哨兵Sentinel实现的。

Redis Cluster集群机制:在Redis3.0版本后推出了redis-cluster集群机制。redis-cluster集群中各个节点之间是对等的，即master-master模式。

注意：Redis Sentinel集群是解决HA问题的（主从同步），Redis Cluster集群是解决sharding问题的（分区），两种不重复，可以混合使用。

Sharding（分库分表）机制：Sharding是把数据库Scale Out到多个物理节点上的一种有效的方式。Shard代表“碎片”，将数据库分片分表则为sharding。 常用的sharding方案

按功能划分（垂直切分） 将不同功能相关的表放到不同的数据库中，譬如将用户管理相关表放到shard1上，将blog相关表放到shard2上。这样做的好处很直观，当需要用户列表时，就到shard1上获取。但是当某一部分的功能其数据量或者性能要求超出了可控的范围，我们就需要继续对其进行深入的sharding。
   
按表中某一字段值的范围划分（水平切分） 当伴随一个表的数据量越来越大，以至于不能承受的时候，就需要进行进一步的切分。一种选择是根据key的范围来做切分，譬如userID范围为1-10000的放到shard 10上，userID为userID为10000到20000的放到shanrd11上，这样的扩展就是可预见的。另一种是根据某一字段值得来划分，譬如根据用户名的首字母，如果是a-d，就属于shard 20，e-h就属于shard21，这样做也存在不均衡性，当某个范围超出了shard所能承受的范围就需要继续切分。还有按日期切分等等。
   
基于hash的切分  类似于memcached的keyhash算法，一开始确定切分数据库的个数，通过hash取模来决定使用哪台 shard。这种方法能够平均的来分配数据，但是伴随着数据量的增大，需要进 行扩展的时候，这种方式无法做到在线扩容。每增加节点的时候，就需要对hash算法重新运算，数据需要重新衔接。
   
基于路由表的切分 基于路由表的切分是一种更加松散的方法。它单独维护一张路由 表，根据用户的某一属性来查找路由表决定使用哪个shard，这种方式是一种更加通用的方案。譬如我们在系统中维护一张表-（用户所属省-〉 shard），这样每个用户我们知道是哪个省的，去路由表查找，就知道它所在的shard。因为每次数据操作的时候都需要进行路由的查找，所以将这些内容 存储到一台独立cache上是一个非常好的方 式，譬如memcached。这种切分的方式同时也带来了另一个好处，当需要增加shard的时候，可以在不影响在线应用的情况下来执行，当然这也跟应用程序的架构设计相关，你的设计必须适用这种增加。 HA机制：通过尽量缩短因日常维护操作和突发的系统崩溃所导致的停机时间，以提高系统和应用的可用性。它与被认为是不间断操作的容错技术有所不同。 下面详解这两种集群，并给出具体的演示示例。

1. Redis Sentinel集群机制 Redis-Sentinel是在master-slave机制上加入监控机制哨兵Sentinel实现的。Sentinel主要功能就是为Redis Master-Slave集群提供：

    监控（Monitoring）： Sentinel 会不断地检查你的主服务器和从服务器是否运作正常。
    
    提醒（Notification）： 当被监控的某个 Redis 服务器出现问题时， Sentinel 可以通过 API 向管理员或者其他应用程序发送通知。

    自动故障迁移（Automatic failover）： 当一个主服务器不能正常工作时， Sentinel 会开始一次自动故障迁移操作， 它会将失效主服务器的其中一个从服务器升级为新的主服务器， 并让失效主服务器的其他从服务器改为复制新的主服务器； 当客户端试图连接失效的主服务器时， 集群也会向客户端返回新主服务器的地址， 使得集群可以使用新主服务器代替失效服务器。
    
    在Sentinel集群中，一个最小的Master-Slave单元包含一个master和一个slave服务器。当master失效后，sentinel自动将slave提升为master，从而可以减少管理员的人工切换slave的操作过程。

2. Redis Cluster集群机制 2.1 Redis-cluster介绍 Redis-cluster是一种服务器Sharding技术，Redis3.0以后版本正式提供支持。Redis-cluster没有使用一致性hash，而是引入了哈希槽的概念。Redis-cluster中有16384个哈希槽，每个key通过CRC16校验后对16384取模来决定放置哪个槽。Cluster中的每个节点负责一部分hash槽（hash slot），比如集群中存在三个节点，则可能存在的一种分配如下：

节点A包含0到5500号哈希槽；节点B包含5501到11000号哈希槽；节点C包含11001 到 16384号哈希槽。这种集群架构很容易扩展，如果扩充一个节点D，只需要将A、B、C节点中的部分槽放置在D上；如果想移除节点A，只需要将A的slot转移到B和C节点上。由于将哈希槽从一个节点移动到另一个节点不需要停止服务，只需要通过命令直接再分配，因而上述拓展不会造成集群不可用。目前这种方式还是一种半自动的方式，需要人工介入。

2.2 Redis-Cluster主从复制在Redis-Cluster中，如果某个节点宕机或者处在不可用状态时，那它负责的Hash槽也将失效，导致整个集群不可用。因而为了提供高可用性，正常会将每个节点配置成主从式结构，即一个master节点，挂载多个slave节点。如果master节点失效时，集群便会选取新一个slave节点作为master，继续提供服务，从而不会导致整个集群不可用。

KMP Algorithms using DFA

2018-03-11T11:49:36+00:00

KMP（Knuth-Morris-Pratt）算法在字符串查找中是很高效的一种算法，假设文本字符串长度为n，模式字符串长度为m，则时间复杂度为O(m+n)，最坏情况下能提供线性时间运行时间保证。

KMP算法的本质是构造一个DFA（确定性有限状态自动机），然后通过自动机对输入的字符串进行处理，每接收一个字符，就能转移到一个新的状态，如果自动机能够达到特定的状态，那么就能够匹配字符串，否则就匹配失败。

先来了解一下DFA。自动机分为两种：DFA和NFA（非确定性有限状态自动机），都可以用来匹配字符串。很多正则表达式引擎使用的就是NFA。

如果有过FPGA开发经验，就会很清楚，自动机与硬件描述语言中常见的状态机类似。状态机是一种流程控制的模型。一个自动机包含多个状态，状态之间可以有条件的进行转移。这个条件就是输入。

根据输入的不同，一个状态可以转移到另一个状态，或者保持当前状态。

下面我再来讲KMP算法。

朴素的字符串查找算法使用的是暴力搜索，过程大概是这样的：假设要处理的文本字符串为s，要在其中查找字符串p（也称为模式字符串）。先将s与p的首字符对齐，然后一个字符一个字符的对比，如果到某个字符不一样，就将p字符串右移一位，然后s与p的字符指针回退到新的对齐的位置，重新开始对比。借用《算法（第四版）》中的代码如下，这里的i和j分别用来跟踪文本与模式字符串，i表示已经匹配过的字符序列的末端：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public int KMPsearch(String pattern, String text) {
    int m = pattern.length();
    int n = text.length();
    int[][] dfa = new int[256][m];
    dfa[pattern.charAt(0)][0] = 1;
    int[] X = new int[m+1];
    X[1] = 0;
    for (int j = 1; j < m; j++) {
        for (int c = 0; c < 256; c++)
            dfa[c][j] = dfa[c][x];
        dfa[pattern.charAt(j)][j] = j + 1;
        X[j + 1] = dfa[pattern.charAt(j)][X[j]];
    }
    int i, j;
    for (i = 0, j = 0; i < n && j < m; i++) {
            j = dfa[text.charAt(i)][j];
    }
    if (j == m) return i - m;
    else return n;
}

以上代码是：对于每个j，匹配失败的时候，dfa[][X[j+1]]复制到dfa[][j]；匹配成功的时候，dfa[pat.charAt(j)][j]设置为j+1；更新X。

为什么这么做呢？因为状态要向后面转移，必须是接收了与模式匹配的正确的字符，每次这个字符有且只有一种情况，这个字符是pat.charAt(j)。其他的字符只能使状态保持或者状态回退。

状态回退也就是让DFA重置到适当的状态，就好像回退过指针一样，但是我们不想回退指针，我们已经有了足够的信息来计算这个重启的位置。

试想一下，如果真的回退指针，我们需要重新扫描文本字符，并且这些字符就是pat.charAt(1)到pat.charAt(j-1)之间的字符（因为前面都是匹配的），忽略首字母是因为需要右移一位，忽略最后一个字符是因为上次匹配失败。重新扫描对比过的文本字符串，直到我们的能够找到一个最长的以pat.charAt(j-1)结尾的子串，能作为模式字符串p的前缀，然后将模式字符串与这个子串的位置对齐，然后重新开始字符对比。

但是实际上，我们不需要回退指针，因为刚才的扫描过程，也是一个状态转移的过程，相当于是一个子问题。我们把pat.charAt(1)到pat.charAt(j-1)之间的字符，一个一个输入当前的得到的DFA（因为只需要处理j-1个字符，所以当前DFA已经足够处理，相当于扫描的时候，只用模式的前一部分），到pat.charAt(j-1)的时候，会停留在一个状态，这个状态就是下一个j的状态。这个过程利用了已经建立好的DFA的信息，进行迭代，得到新的DFA的信息，所以可以这样把整个DFA都建立起来。

dfa[text.charAt(i)][j]是指当文本字符串的字符s[i]与模式字符串的字符p[j]比较后下一次与文本字符串的字符s[i+1]比较的模式字符串的字符位。当文本字符串的第i位字符与模式字符串的第j位进行匹配时，如果此两位字符匹配，则说明下一步应该为i++, j++之后再比较，也就是说当txt.charAt(i)==pat.charAt(j)时，有dfa[pat.charAt(j)][j]=j+1。

当文本字符串的第i位字符与模式字符串的第j位检测到不匹配时，设txt.charAt(i)==c，c!=pat.charAt(j)，但文本字符串的s[i-j…i-1]这部分与模式字符串的p[0…j-1]这部分是匹配的。这时从文本字符串的i-j位置起已不可能出现匹配字符串，现在已不用管s[i-j]字符，现在的问题是依次输入s[i-j+1…i-1]c后会进入什么状态，由于s[i-j…i-1]这部分与模式字符串的p[0…j-1]这部分是匹配的，也就是说现在的问题是依次输入p[1…j-1]c后会进入什么状态。引入一个状态指示数组X，X[j]是指正确输入p[1…j-1]后进入的状态，输入p[1…j-1]c后进入的状态就是dfa[c][X[j]]（在X[j]状态时输入c），即dfa[c][j]=dfa[c][x[j]]。而计算X[]数组的方法为递推方法：X[j+1]为正确输入p[1…j]后进入的状态，即正确输入p[1…j-1]p[j]后进入的状态，也就是在X[j]状态时输入p[j]时进入的状态，就是dfa[pat.charAt[j]][X[j]]，即递推公式为：X[j+1]=dfa[pat.charAt[j]][X[j]]，而X[0]手动初始化为0。由于X[]数组为辅助数据，且为递推的，所以书中仅使用了一个变量X来指示当前的X[j]，我觉得理解起来很不方便，所以这里由数组代替。

The For-Each Loop

2018-03-09T14:05:36+00:00

Iterating over a collection is uglier than it needs to be. Consider the following method, which takes a collection of timer tasks and cancels them:

1
2
3
4
void cancelAll(Collection<TimerTask> c) {
    for (Iterator<TimerTask> i = c.iterator(); i.hasNext(); )
        i.next().cancel();
}

The iterator is just clutter. Furthermore, it is an opportunity for error. The iterator variable occurs three times in each loop: that is two chances to get it wrong. The for-each construct gets rid of the clutter and the opportunity for error. Here is how the example looks with the for-each construct:

1
2
3
4
void cancelAll(Collection<TimerTask> c) {
    for (TimerTask t : c)
        t.cancel();
}

When you see the colon (:) read it as “in.” The loop above reads as “for each TimerTask t in c.” As you can see, the for-each construct combines beautifully with generics. It preserves all of the type safety, while removing the remaining clutter. Because you don’t have to declare the iterator, you don’t have to provide a generic declaration for it. (The compiler does this for you behind your back, but you need not concern yourself with it.)

Here is a common mistake people make when they are trying to do nested iteration over two collections:

1
2
3
4
5
6
7
List suits = ...;
List ranks = ...;
List sortedDeck = new ArrayList();
// BROKEN - throws NoSuchElementException!
for (Iterator i = suits.iterator(); i.hasNext(); )
    for (Iterator j = ranks.iterator(); j.hasNext(); )
        sortedDeck.add(new Card(i.next(), j.next()));

Can you spot the bug? Don’t feel bad if you can’t. Many expert programmers have made this mistake at one time or another. The problem is that the next method is being called too many times on the “outer” collection (suits). It is being called in the inner loop for both the outer and inner collections, which is wrong. In order to fix it, you have to add a variable in the scope of the outer loop to hold the suit:

1
2
3
4
5
6
// Fixed, though a bit ugly
for (Iterator i = suits.iterator(); i.hasNext(); ) {
    Suit suit = (Suit) i.next();
    for (Iterator j = ranks.iterator(); j.hasNext(); )
        sortedDeck.add(new Card(suit, j.next()));
}

So what does all this have to do with the for-each construct? It is tailor-made for nested iteration! Feast your eyes:

1
2
3
for (Suit suit : suits)
    for (Rank rank : ranks)
        sortedDeck.add(new Card(suit, rank));

The for-each construct is also applicable to arrays, where it hides the index variable rather than the iterator. The following method returns the sum of the values in an int array:

1
2
3
4
5
6
7
// Returns the sum of the elements of a
int sum(int[] a) {
    int result = 0;
    for (int i : a)
        result += i;
    return result;
}

So when should you use the for-each loop? Any time you can. It really beautifies your code. Unfortunately, you cannot use it everywhere. Consider, for example, the expurgate method. The program needs access to the iterator in order to remove the current element. The for-each loop hides the iterator, so you cannot call remove. Therefore, the for-each loop is not usable for filtering. Similarly it is not usable for loops where you need to replace elements in a list or array as you traverse it. Finally, it is not usable for loops that must iterate over multiple collections in parallel. These shortcomings were known by the designers, who made a conscious decision to go with a clean, simple construct that would cover the great majority of cases.

Algorithms–Chapter.1 Sorting and Searching

2018-02-27T08:41:36+00:00

马上也快找实习了，也该把刷题需求提上日程啦，加油加油！

这个博客也有很久没有更新了，趁这个机会重新开坑嘻嘻。

首先来介绍下几种排序算法

1.插入排序（Insertion Sort)

Insertion sort is a brute-force sorting algorithm that is based on a simple method that people often use to arrange hands of playing cards: Consider the cards one at a time and insert each into its proper place among those already considered (keeping them sorted). The following code mimics this process in a Java method that sorts strings in an array:

source code

1
2
3
4
5
6
7
8
9
10
public void insertionSort(String[] a) {
    int n = a.length;
    for (int i = 1; i < n; i++) {
        for (int j = i; j > 0; j--) {
            if (a[j-1].compareTo(a[j]) )
            exch(a, j, j-1);
            else break;
        }
    }
}

2.选择排序（Selection Sort)

One of the simplest sorting algorithms works as follows: First, find the smallest item in the array, and exchange it with the first entry. Then, find the next smallest item and exchange it with the second entry. Continue in this way until the entire array is sorted. This method is called selection sort because it works by repeatedly selecting the smallest remaining item. Selection.java is an implementation of this method.

source code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
public void selectionSort(Comparable[] a) {
    int n = a.length;
    for (int i = 0; i < n; i++) {
        int min = i;
        for (int j = i+1; j < n; j++) {
            if (less(a[j], a[min])) min = j;
        }
        exch(a, i, min);
    }
}

private static boolean less(Comparable v, Comparable w) {
    return v.compareTo(w) < 0
}

private static void exch(Object[] a, int i, int j) {
    Object swap = a[i];
    a[i] = a[j];
    a[j] = swap;
}

写给研究生阶段迷茫的自己

2017-05-04T14:05:36+00:00

最近感慨良多，似乎是感受到现实与预期不符的落差了。挺羡慕身边那些可以出国继续做机器学习、人工智能方向的同学们。但这样想也太丧了，我也有自己的用武之地。生怕自己硕士毕业之后拿到的offer没有预期的漂亮，所以看书总是左顾右盼。昨天和吴小姐已经在一起三个月了，感觉也挺好的吧，有点稳。人生总是需要一点激励的东西才能够帮助自己走得更远。

你不是一个行动草率的人。
你经常会对自己所做的事情突然失去兴趣。
坚持自己的人生目标，你一定会成功的！
如果你想得到别人的赞美，
就不要自吹自擂！

不要朝思暮想，努力做好你应该做的事情。

首先要自律。保持专注，做到心无旁骛。

接下来要跳出舒适区。举个例子，勤奋本来就是舒适区的一种。 “勤能补拙”这个词是很好的，首先它说明现在处于“拙”的状态中，需要继续努力；其次，勤只能用来“补”拙，而不能让拙变巧，不是根本的解决方案。勤奋是一种惶惶然的状态，而不是一种满足的状态，勤奋意味着自己不如别人，于是得要花更多的时间去补救，别人干八小时就够了，自己得花十几个小时才能赶上。这种状态是不长久的，碰到出些小毛小病，或者家里有事，那就补不过来，就要掉队了。勤奋的用处是试错，是让自己在落后时可以多花点时间找到正确的方法，以达到和别人相当甚至更高的效率，从而提高自己的能力。别人是科班出身，我半路杀进来，当然要多花时间去补；别人学习效率高，我的效率不高，于是得要多花点时间去探索更好的方法。勤奋是暂态，它最终目的是找到更好的方法及时补上以离开这个状态，而不是以一直维持这个状态为荣。

不能按部就班，要随时作好把棋盘翻过来的准备，世事变化很快，以前的所有努力，不管经历过什么样的辛劳，全都是沉没成本，在必要时候都需要扔掉的，或许做了很多年方向A，时势告诉你情况不妙，要换成方向B，那就得坚决换。以前或许这个不常见，但是以后这样的事情会越来越多。干了十年方向A，人工智能把方向A吃掉了，然后马上转做方向B，做了五年，人工智能再把B吃掉，然后继续，如此往复。很多时候转变不是一朝一夕，而是靠滴水穿石的功夫，今天长进一点，明天长进一点，跟着领域一起变，若是一个人跑得比别人快，他就会在市场上稀缺并因此获得相对的安全。做研究的人都习惯这个，每天看新东西，每天打开思路，时刻承认自己老旧了几个月或者几周，马上拍拍屁股跟上。学会了这些再去教徒弟是饿不死师傅的，反而让师傅变得更厉害，因为师傅主动跳出来接受打脸，学得比徒弟快。对很多人来说这个比较难，特别是一直顺风顺水的。但若是一直不敢看外面的世界，那迟早有一天会被逼进去面对。与其被逼，不如提早一些主动跳进去。历史无数次以血的教训告诉了大家，适者生存乃永恒之铁律，人类在千万物种中杀出血路成为地球的主宰，也必将背负着这样的命运走向未来。一个人逃避，这个人会被淘汰，一个领域逃避，这个领域会被淘汰，一个国家逃避，这个国家就会被淘汰。

任何时候，自己一定是有错的，最可怕的不是自己错了，而是不知道自己哪里错，并且在错的方向上越走越远。如果周围有厉害的同事，这种感觉尤其强烈，碰上了随便讨论两句，就知道自己哪些知识不足，暗地里记下马上回去补。为此，主动发言积极讨论是很重要的，思维有碰撞才知道问题在哪里。我有时候觉得自己一直在悬崖边上走，也许之前走得还行，但那都过去了，下一步随时有可能踏进崖边的泥地即将摔倒。踏错了不要紧，及时发现自己错了收脚就行；怕的是一直走安稳的道，连悬崖长什么样都不知道了。前辈和老师们说的话，也非常有可能是错的，而身为后辈的我们，大任在于如何找出他们的错误来。找出了的话，能力就得到了提升。而自信，往往就是通过这种方式磨练出来的——为什么自己和别人不同？因为选了一条不一样的路。

再往上走，主次是要分清的。重要的要抓牢，不重要的要放手。有人读过很多文章看过很多书，勤勉自律好学爱问样样不缺，但门门都不精；有人事事亲为，务求完美，大事上往往把握不了。短木板理论是有问题的，大部分岗位不需要全才，要的是一专多能，要的是某方向很牛非常牛，相同程度的可以掰指头数过来，其它的过线就行，甚至不达标也无人关心。如果你不是专家，高薪聘请没有意义；如果你是专家，求全责备没有意义。人一天只有24小时，所以知道哪里要放弃是很重要的，很多时候，没有牺牲就没有得到，要得到就得付出代价，事前权衡利弊，事后愿赌服输。输了不要紧，再来一次。当然在现实中并没有那么惨烈的权衡，而往往是找到了自己的方向，自然而然地就向这个方向发展下去，这时候主要的阻力，就在于登顶之难而非选择之痛。然而，即便生于风平浪静的和平年代，觉悟依然要有，或许将来有一天，得要做出这样的决断。

最后，不要在优越感中停止自己的脚步。名利于人最可怕的莫过于此，分明刚刚启程，但欢呼声让你觉得已然冲线，本来要万里长征，却变成了百米短跑，接受完了鲜花之后，就再也看不见远处的风景。其实境界到了或是未到，只有自己知道。跋山涉水，风餐露宿，鼓掌的是别人，度化的是自己。

尽量少去横向对比，多去纵向对比，每天8小时之外能有一点进步，那就完成自己的初衷了。

Mac 中CMake编译错误无法正确读取系统信息

2017-04-20T11:47:36+00:00

在准备一个验证0..1000中有多少个”7”时，就随手下了个CLion。之前一直是在实验室的电脑用CLion写C++来着，用着很舒服。对CLion进行配置之后进行编译时出现以下错误：

> /Applications/CMake.app/Contents/bin/cmake -DCMAKE_BUILD_TYPE=Debug -G "CodeBlocks - Unix Makefiles" /Users/changeset/CLionProjects/untitled
> -- The C compiler identification is AppleClang 8.1.0.8020038
> -- The CXX compiler identification is AppleClang 8.1.0.8020038 CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeSystemSpecificInformation.cmake:26
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> CMakeLists.txt:2 (PROJECT)
> 
> 
> System is unknown to cmake, create: Platform/sysname:Darwin 
> nodename:Fez.local  release:16.5.0  version:Darwin Kernel Version
> 16.5.0: Fri Mar  3 16:52:33 PST 2017; root:xnu-3789.51.2~3/RELEASE_X86_64  machine:x86_64 to use this
> system, please send your config file to cmake@www.cmake.org so it can
> be added to cmake Your CMakeCache.txt file was copied to
> CopyOfCMakeCache.txt. Please send that file to cmake@www.cmake.org.
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:38
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> CMakeLists.txt:2 (PROJECT)
> 
> 
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:41
> (include):   include called with invalid argument:
> root:xnu-3789.51.2~3_RELEASE_X86_64
> 
>    machine:x86_64 Call Stack (most recent call first):  
> CMakeLists.txt:2 (PROJECT)
> 
> 
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:48
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> CMakeLists.txt:2 (PROJECT)
> 
> 
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:52
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> CMakeLists.txt:2 (PROJECT)
> 
> 
> -- Check for working C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/cc
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeSystemSpecificInformation.cmake:26
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> /Users/changeset/CLionProjects/untitled/cmake-build-debug/CMakeFiles/CMakeTmp/CMakeLists.txt:2
> (project)
> 
> 
> System is unknown to cmake, create: Platform/sysname:Darwin 
> nodename:Fez.local  release:16.5.0  version:Darwin Kernel Version
> 16.5.0: Fri Mar  3 16:52:33 PST 2017; root:xnu-3789.51.2~3/RELEASE_X86_64  machine:x86_64 to use this
> system, please send your config file to cmake@www.cmake.org so it can
> be added to cmake CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:38
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> /Users/changeset/CLionProjects/untitled/cmake-build-debug/CMakeFiles/CMakeTmp/CMakeLists.txt:2
> (project)
> 
> 
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:41
> (include):   include called with invalid argument:
> root:xnu-3789.51.2~3_RELEASE_X86_64
> 
>    machine:x86_64 Call Stack (most recent call first):  
> /Users/changeset/CLionProjects/untitled/cmake-build-debug/CMakeFiles/CMakeTmp/CMakeLists.txt:2
> (project)
> 
> 
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:48
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> /Users/changeset/CLionProjects/untitled/cmake-build-debug/CMakeFiles/CMakeTmp/CMakeLists.txt:2
> (project)
> 
> 
> CMake Error at
> /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeCInformation.cmake:52
> (include):   include called with wrong number of arguments.  include()
> only takes one   file. Call Stack (most recent call first):  
> /Users/changeset/CLionProjects/untitled/cmake-build-debug/CMakeFiles/CMakeTmp/CMakeLists.txt:2
> (project)
> 
> 
> CMake Error: Internal CMake error, TryCompile configure of cmake
> failed
> -- Check for working C compiler: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/cc
> -- broken CMake Error at /Applications/CMake.app/Contents/share/cmake-3.7/Modules/CMakeTestCCompiler.cmake:51
> (message):   The C compiler  
> "/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/cc"
> is not able to compile a simple test program.
> 
>   It fails with the following output:
> 
>    
> 
>   
> 
>   CMake will not be able to correctly generate this project. Call
> Stack (most recent call first):   CMakeLists.txt:2 (PROJECT)
> 
> 
> -- Configuring incomplete, errors occurred! See also "/Users/changeset/CLionProjects/untitled/cmake-build-debug/CMakeFiles/CMakeOutput.log".
> See also
> "/Users/changeset/CLionProjects/untitled/cmake-build-debug/CMakeFiles/CMakeError.log".

熬夜到3点都没查出来CMake是怎么读取系统文件的。

Finally, I solved my problems here. It seems to be unusual.

The errors listed about CMake were caused by incorrectly invokinguname.

I checked out the CMake manual, and I found that my mac produced the wrong CMAKE_HOST_SYSTEM_NAME results. And after test uname on my terminal, I found that maybe the kernel used wrong command. And then I echo $PATH found that my $PATH changed by cocos2d-x installed yesterday. The new $PATH include my uname programmed for study, and it overrided the kernel uname. After I delete my uname, clean CMake, restart CLion, everything is just going fine. Done.

这个uname是去年做毕设时余留的产物，所以覆盖了kernel中的uname。

最后附上那个0..1000中有多少个”7”的验证程序。其实更简单的算法是把1-999中的个位、十位、百位中7做组合也就是每一位为7的数有10 * 10 = 100个，总共就是100 * 3 = 300个。

#include <iostream>
using namespace::std;
int main() {
    int m, n;
    int temp, count = 0;
    cin >> m >> n;
    for (int i = m; i < n; i++){
        temp = i;
        while (temp) {
            if ((temp % 10) == 7){
                count ++;
            }
            temp /= 10;
        }
    }
    cout << "numbers of 7: " << count << endl;
    return 0;
}

你能从这里找到我：

我的微博

我的知乎

我也很忙，就先这样。

Test

2017-04-14T11:31:36+00:00

测试，测试~

这是一个

技术博客
情感博客
励志博客

#include <iostream>
using namespace::std;
void main(){
    cout << "Hello, World!" << endl;
}

你能从这里找到我：

我的微博

我的知乎

腾讯防水墙

我也很忙，就先这样。