书摘:

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

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. 双曲贴现

这是一本非常实用的书，很多人没有意识到这个问题————自己的思维方式有问题。最近看了很多有关思维，有关元认知方面的书。深刻的认识到，你如果想要做出改变，就必须从思维上，进行彻底的改变。

改变思维这条路挺难的，但仍旧是有方法的，仍旧是有突破点的。这本书里提到的52个偏误，其实就是很好的突破点。

有的同学也会说，我怎么能记住这么多啊，怎么可能在要犯错误的时候，想到我是不是犯了错误？很多人做不到这一点，所以古人说了，要每天反省自己。

对照着列表，我们检视自己，看是否自己范了某些错误，有则改之，无则加勉。很简单，但要坚持。

这本书我看了很多遍，开始就是理解，后面就是检视自己，我还将里面的某些偏误，就写在我自己的手机便签里，时不时的打开看看。让我更加清醒的认识自己，认识世界。一本小书，看起来蛮轻松，不过有的时候也会一阵毛骨悚然，有的时候也会一阵恍然大悟，原来如此。如果有这些，那这本书的阅读，就是值了的。
52个偏误，我就只讲一个吧。

现在创业很热，从国家的高度也说明了，还有股市创业板一度那么疯狂，都吸引了很多人投入创业的大军中，无论是互联网行业，还是传统行业。我听得最多的就是，我们就差一个程序员了。你们真的就差一个程序员了么？是全栈的么？呵呵。

创业不易，你首先需要看看这本书的第一个偏误。你看到的都是成功的案例，暴富的案例，一个屌丝程序员逆袭成为CEO的案例。你真的了解，每天会死掉多少个团队么？作为这个大军中的一员，我想成功的比例，万中无一。而且这个比例，都是高估的。

当然，创业不成功的原因有很多，开始的盲目，不够冷静只是其中之一。说这些，只是想大家在创业之前，多和一些团队聊聊，多去一些孵化器看看，问问他们有多个满怀梦想的年轻人，以落寞收场？

还有一个很残酷的现实，如果你有投资机构的朋友，和他们深入聊聊，让他们告诉你，创业的现实是什么？只能说，很残酷，白手起家，会越来越少，越来越不可能。

后面我会有一篇文章，专门来讲，创业的现实。

这本书的书名误导了很多人，大家以为只有程序员才可以看的。实际上不是的，所有行业的人都可以看。这本书的副标题，《开发认知潜能的九堂课》，是很适合的。
这是一本，提高大家认知能力的书，并不是心灵鸡汤，而是有实实在在的方法的，确确实实的理论依据的。而且，全书行文流畅，阅读起来非常轻松。
书中讲到的一些实践的方法，大家多多尝试，非常有帮助。
由于书的作者是程序员，所以，书中会有些例子是程序员相关的，如果你也是，读起来肯定很亲切。如果不是，也不会影响阅读的。

不知道大家是否有这种经历：在思考某些问题的时候，一步一步深入，一步一步提高到一定程度，就好像紧了一间屋子，这个屋子只有入口，好像没有出口。
但我知道，只要我能够找到出出口，或者我造了出口，我就可以进入一个更加广阔的世界。但之前，我一直没有好的办法，最近的几本书，给我带来了一些改变。
我也知道了，尽管我之前的尝试，好像没有效果，但都是在积累，等待爆发，这让我不是那么的气馁。今天的读书笔记，就是其中一本，我也推荐给大家。无论大家是不是程序员。不过，我是。

下面是书中提高的诀窍，基本上，每个诀窍，都对应着一些实践，实践方法，大家看书就可以了。

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

诀窍一：始终关注情境
诀窍二：新手使用规则，专家使用直觉
诀窍三：知道你不知道什么
诀窍四：通过观察和模仿来学习
诀窍五：保持实践以维持专家水平
诀窍六：如果你需要创造力，直觉或者独创技能，避免使用形式方法
诀窍七：学习如何学习的技能
诀窍八：捕获所有的想法以从中获益更多
诀窍九：综合学习与分析学习并重
诀窍十：争取好的设计，它真的很有效
诀窍十一：重新连线大脑，坚信这一点并不断实践
诀窍十二：增加感官体验以促进大脑的使用
诀窍十三：R型开路，L型紧跟
诀窍十四：使用隐喻作为L型和R型相融之处
诀窍十五：培养幽默感以建立更强大的隐喻
诀窍十六：离开键盘去解决难题
诀窍十七：改变解决问题的角度
诀窍十八：推迟下结论
诀窍十九：适应不确定性
诀窍二十：信任记录而不是记忆，每一次思维的输出都是一次输入
诀窍二十一：从多个角度看待问题
诀窍二十二：尊重不同人的不同性格
诀窍二十三：想高级动物一样行动，请做深呼吸，而不要张口嘶鸣
诀窍二十四：相信直觉，但是要验证
诀窍二十五：建立SMART任务实现你的目标
诀窍二十六：对主动学习的投资做好计划
诀窍二十七：发现你的最佳学习方式
诀窍二十八：组织学习小组学习和辅导
诀窍二十九：主动阅读
诀窍三十：同时用R型和L型做笔记
诀窍三十一：写文档的过程比文档本身更重要
诀窍三十二：观察、实践、教学
诀窍三十三：为了更好地学习，请更好地玩
诀窍三十四：从相似点中学习，从差异中忘却
诀窍三十五：在你的环境中安全地探索、创造和应用
诀窍三十六：观察，不做判断，然后行动
诀窍三十七：允许失败，你会走向成功
诀窍三十八：让大脑为成功形成惯例
诀窍三十九：学会集中注意力
诀窍四十：挤出思维时间
诀窍四十一：使用wiki来管理信息和知识
诀窍四十二：指定交流规则来管理干扰
诀窍四十三：少发送邮件，你就会少收到邮件
诀窍四十四：为邮件通信选择你自己的进度
诀窍四十五：屏蔽中断来保持注意力
诀窍四十六：使用多台显示器来避免情境切换
诀窍四十七：优化你的个人工作流以达到最大化情境
诀窍四十八：抓住方向盘，你不能自动驾驶

1

如果你能让一个组织中的所有成员齐心协力，你就可以在任何时候、任何市场状况下、任何行业中纵横驰骋，战胜挑战。

这是一家年利润10亿美金的公司的创始人说的，也是这本书核心————如何进行团队协作。这个看似简单，但实际上，绝大多数团队是无法达到的。这里面的根源在哪里呢？
本书的作者进行了研究，总结了团队协作中的五大障碍，非常有道理、非常有说服力：

1. 缺乏信任
2. 惧怕冲突
3. 欠缺投入
4. 逃避责任
5. 无视结果

这五条，如果细细展开，大家都或多或少会找到一些自己曾经犯过的错误。

缺乏信任

很多人可能不服气，觉得自己的团队不存在这个。但往往并不是像大家想的那么简单，团队成员之间可能会有怀疑，能力方面等等，但怕惹事儿，或者被攻击，藏在心里不说，表面上看起来好一致，和美好。但问题总是会爆发的。
书里面讲了很多缺乏信任的特点，大家可以一一看看，是不是冷汗慢流了下来？对于解决这个障碍的方法，作者也提出了自己的一些方案。比如说，每个人介绍自己的童年经历，介绍自己的爱好，介绍自己以前面临的困难等等，还有批评与自我批评等等建议。大家可以看书体会一下。

惧怕冲突

一个良好的合作关系，是需要积极的争吵、冲突的。哪怕吵的过程中面红耳赤，好像要动手了。但大家都是为了事情能够更好的推进发展，都是针对事情的，而不是人的。所以不用惧怕被针对，或者不被理解。炒炒更健康，很多人不敢面对面争论，但却在背后说闲话，这种方式实在是团队里的病毒。这样，表面上开会讨论，都达成了一致，但实际上，心里缺不认同，背后胡言乱语，执行推三阻四，只有失败。
在处理这个冲突的时候，负责人要忍住，不要去平衡什么，负责人本身，就不应该害怕冲突。

欠缺投入

欠缺投入的表现有团队的指令和主要工作任务模糊，由于不必要的拖延而错过商机，大家缺乏自信，惧怕失败，反复讨论，无法做出决定。做出决定之后，反复质疑。为什么是欠缺投入呢？主要是大家观点阐述不够清晰，无法达成共识，追求绝对的一致，追求绝对的控制。我们懂点道理的人都知道，这后面的两个绝对，是不可能达成的。所以，我们要在认可不一致，不绝对的存在之下，全力执行达成一致的结论。
每个人把自己的观阐述的越清楚，对于最终的结论的理解，认可就会越高。所以，要达成一致，并不是绝对的一致，然后统一口径，这是针对管理层的。项目上，确定最终共期限，非常有帮助。

逃避责任

这一条涉及更多的任性，某些人，对于表现好的员工，心怀怨恨，嫉妒，自己缺甘于平庸；缺乏明确的时间观念，把所有责任推到leader一个人身上。其实，一个高效协作的团队，如果发现队友有错误，应当直接指出，不应该藏着，更不应该讽刺的。这个障碍的解决办法，很有用：1. 公布工作的目标和标准；2. 定期对成果进行回顾；3. 团队嘉奖。无论什么时期，一定要明确每个人的工作。有一个良好的激励机制。

无视结果

大家是作为一个团队在做事。是为了团队的一个共同的目标。就好像打篮球一样，只有一个人的超强突出，不如每个人都很均衡，高效的配合。这个结果有个人的结果，集体的结果。而且，集体的结果必须在个人的结果之上。

适合谁

一切需要高效团队协作的团队。尤其是创业团队，这些问题，如果不解决，人好好的创业，看似豪华的团队阵容，都会走向失败。原因就是上面这五点。

一周看完一本书，挑战挺大的，还好这本书比较轻，绝大部分都是以故事的形式展现出来的，建议大家看看，是否在故事中，能找到你的影子，如果能，那么你需要改变了。

向所有创业者推荐这本书。

题目

设计一个Stack，实现如下操作：

1. push(), 入栈
2. pop(), 出栈
3. top(), 返回栈顶元素
4. getMin(), 返回栈中的最小元素

注意上面的操作，都要在常数时间完成。

分析

Leetcode上面的原题，思路并不难想，但是AC还是有难度的，尤其是用Java，如果能够确保不出现MLE？我们先逐步分析一下。

首先，第一个思路，最容易想到，定义一个新的栈，栈的每一个元素包含两个数，一个当前数，一个入栈到目前为止的最小数。有如下的代码示例：

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

class Element {
    public int x;
    public int min;
    public Element(int x, int min) {
        super();
        this.x = x;
        this.min = min;
    }
}
public class MinStackSlow {
    
    private LinkedList<Element> stack = new LinkedList<Element>();
    
    public void push(int x) {
        int min = x;
        if (!stack.isEmpty() && stack.getFirst().min < min) 
            min = stack.getFirst().min;
        stack.addFirst(new Element(x, min));
    }
    public void pop() {
        stack.removeFirst();
    }
    public int top() {
        Element el = stack.getFirst();
        return el.x;
    }
    public int getMin() {
        return stack.getFirst().min;
    }
}

代码很简单，但是MLE，内存超了。。。很不幸。那么如何优化呢？其实我们自己走一走这个过程，就会发现，在入栈出栈，以及getMin的过程中，有一些值，是不会出现在getMin中的。有一些min的数都是一样的。

那么我们浪费了空间来存储这些一样的min值，显然是不可以的。我们做如下的优化，用另外一个栈来保存最小值，每一个栈元素除了包括最小值之外，还有一个频率。这样我们压缩了存储最小值的栈。比之前的栈要小很多。

示例代码如下：

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

class MinElement {
    public int min;
    public int freq;
    public MinElement(int min, int freq) {
        this.min = min;
        this.freq = freq;
    }
}
public class MinStack {
    
    private LinkedList<Integer> stack = new LinkedList<Integer>();
    private LinkedList<MinElement> min = new LinkedList<MinElement>();
    
    public void push(int x) {
        if (min.isEmpty()) {
            min.addFirst(new MinElement(x, 1));
        } else {
            if (x == min.getFirst().min) {
                min.getFirst().freq += 1;
            } else if (x <  min.getFirst().min) {
                min.addFirst(new MinElement(x, 1));
            }
        }
        stack.addFirst(x);
    }
    public void pop() {
        int top = stack.removeFirst();
        if (top == min.getFirst().min) {
            if (min.getFirst().freq == 1) {
                min.removeFirst();
            } else {
                min.getFirst().freq -= 1;
            }
        }
    }
    public int top() {
        return stack.getFirst();
    }
    public int getMin() {
        return min.getFirst().min;
    }
}

提交之后，你会发现，代码还是有问题，人就是内存不过关，还能怎么优化呢？难道是LinkedList的问题？实际上，还真是这个问题。Java中LinkedList是一个双向的链表，实际上我们实现一个栈，只需要单向的。我们自己实现栈试试。代码比较糙，有些实现也不合规范。
但意思没问题，如下：

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

package leetcode.min.stack;
class IntNode {
    public int x;
    public IntNode next;
    public IntNode(int x, IntNode next) {
        this.x = x;
        this.next = next;
    }
}
class IntStack {
    private IntNode head;
    public void push(int x) {
        if (null == head) {
            head = new IntNode(x, null);
        } else {
            IntNode newHead = new IntNode(x, head);
            head = newHead;
        }
    }
    public void pop() {
        head = head.next;
    }
    public int top() {
        return head.x;
    }
}
class PairNode {
    public int min;
    public int freq;
    public PairNode next;
    public PairNode(int min, int freq, PairNode next) {
        super();
        this.min = min;
        this.freq = freq;
        this.next = next;
    }
}
class PairStack {
    private PairNode head;
    public void push(int x) {
        if (null == head) {
            head = new PairNode(x, 1, null);
        } else {
            if (x == head.min) {
                head.freq += 1;
            } else if (x < head.min) {
                PairNode newHead = new PairNode(x, 1, head);
                head = newHead;
            }
        }
    }
    public void pop(int x) {
        if (x == head.min) {
            if (head.freq > 1) {
                head.freq -= 1;
            } else {
                head = head.next;
            }
        }
    }
    public int top() {
        return head.min;
    }
}
public class SmallMemoryStack {
    private IntStack stack = new IntStack();
    private PairStack min = new PairStack();
    public void push(int x) {
        stack.push(x);
        min.push(x);
    }
    public void pop() {
        min.pop(stack.top());
        stack.pop();
    }
    public int top() {
        return stack.top();
    }
    public int getMin() {
        return min.top();
    }
}

通过了，看来问题确实如此。这也给了我们一个提醒，在实际的编码中，需要考虑的不仅仅是功能的实现，还有效率上的考虑。我们往往优先考虑时间，大多数时间考虑时间。但，空间也是同样重要的，尤其是Java这样的语言。

【完】

旋转数组最小值II

题目

一个有序的数组，在从某一个位置开始，旋转到数组的另一端

举例：

0 1 2 3 4 5 6 -> 4 5 6 0 1 2 3

在这个变换之后的数组中，找到最小值。

注意：

• 有可能不旋转的哦。
• 数组元素有重复

题目来自Leetcode: Find Minimum in Rotated Sorted Array II

Read More

简介

过去几年，深度神经网络在模式识别中占绝对主流。它们在许多计算机视觉任务中完爆之前的顶尖算法。在语音识别上也有这个趋势了。

虽然结果好，我们也必须思考……它们为什么这么好使？

在这篇文章里，我综述一下在自然语言处理（NLP）上应用深度神经网络得到的一些效果极其显著的成果。我希望能提供一个能解释为何深度神经网络好用的理由。我认为这是个非常简练而优美的视角。

Read More

题目

一个有序的数组，在从某一个位置开始，旋转到数组的另一端

举例：

0 1 2 3 4 5 6 -> 4 5 6 7 0 1 2

在这个变换之后的数组中，找到最小值。注意：有可能不旋转的哦。

题目来自Leetcode: Find Minimum in Rotated Sorted Array

Read More

题目

给定一个数组，至少有一个元素。请计算子数组最大乘积是多少？

例如：

• 给定数组 [2, 3, -2, 4]
• 经过计算，得到最大乘积为6。子数组为[2,3]。

题目来自Leetcode。

分析

这个题目，有经验的同学，看过一遍，就知道肯定是动态规划了，可具体要如何规划呢？我想，有的同学还记得子数组的最大和吧？是不是觉得很激动，O(n)就可以解决了。一样的思路！但是不好意思，错了！

错在哪里呢？乘法口诀还记得么？负负得正，就可恶在这里。在加法里，负负可得不到正。

Read More

今天受到雪球@雷公资本 博文 的启发，百度指数、Google趋势都可以作为大家投资工具集里的一个小工具，对于趋势判断也许有帮助。正好，我们收集了很多美股市场的数据，正在琢磨怎么来用。于是就做了一个我们数据集上的趋势指数，希望对大家能有帮助。请大家玩玩：猛击

目前只支持美股，所以信息都是英文的。大家搜索时，可以采用英文的关键词。

主要数据：

1. 财经新闻
2. SeekingAlpha
3. Twitter
4. StockTwits
5. Facebook
6. …

大家可以看出来，我们的数据除了Google有的，也有Google没有的~~~

Read More

简介

Read More