分享一些有趣的面试智力题（下） | Matrix67: The Aha Moments

12. 两个机器人，初始时位于数轴上的不同位置。给这两个机器人输入一段相同的程序，使得这两个机器人保证可以相遇。程序只能包含"左移n个单位"、"右移n个单位"，条件判断语句If，循环语句while，以及两个返回Boolean值的函数"在自己的起点处"和"在对方的起点处"。你不能使用其它的变量和计数器。
答案：两个机器人同时开始以单位速度右移，直到一个机器人走到另外一个机器人的起点处。然后，该机器人以双倍速度追赶对方。程序如下。

while(!at_other_robots_start) {
move_right 1
}
while(true) {
move_right 2
}

    13. 如果叫你从下面两种游戏中选择一种，你选择哪一种？为什么？
      a. 写下一句话。如果这句话为真，你将获得10美元；如果这句话为假，你获得的金钱将少于10美元或多于10美元（但不能恰好为10美元）。
      b. 写下一句话。不管这句话的真假，你都会得到多于10美元的钱。
    答案：选择第一种游戏，并写下"我既不会得到10美元，也不会得到10000000美元"。

14. 你在一幢100层大楼下，有21根电线线头标有数字1..21。这些电线一直延伸到大楼楼顶，楼顶的线头处标有字母A..U。你不知道下面的数字和上面的字母的对应关系。你有一个电池，一个灯泡，和许多很短的电线。如何只上下楼一次就能确定电线线头的对应关系？
答案：在下面把2,3连在一起，把4到6全连在一起，把7到10全连在一起，等等，这样你就把电线分成了6个"等价类"，大小分别为1, 2, 3, 4, 5, 6。然后到楼顶，测出哪根线和其它所有电线都不相连，哪些线和另外一根相连，哪些线和另外两根相连，等等，从而确定出字母A..U各属于哪个等价类。现在，把每个等价类中的第一个字母连在一起，形成一个大小为6的新等价类；再把后5个等价类中的第二个字母连在一起，形成一个大小为5的新等价类；以此类推。回到楼下，把新的等价类区别出来。这样，你就知道了每个数字对应了哪一个原等价类的第几个字母，从而解决问题。

15. 某种药方要求非常严格，你每天需要同时服用A、B两种药片各一颗，不能多也不能少。这种药非常贵，你不希望有任何一点的浪费。一天，你打开装药片A的药瓶，倒出一粒药片放在手心；然后打开另一个药瓶，但不小心倒出了两粒药片。现在，你手心上有一颗药片A，两颗药片B，并且你无法区别哪个是A，哪个是B。你如何才能严格遵循药方服用药片，并且不能有任何的浪费？
答案：把手上的三片药各自切成两半，分成两堆摆放。再取出一粒药片A，也把它切成两半，然后在每一堆里加上半片的A。现在，每一堆药片恰好包含两个半片的A和两个半片的B。一天服用其中一堆即可。

16. 你在一个飞船上，飞船上的计算机有n个处理器。突然，飞船受到外星激光武器的攻击，一些处理器被损坏了。你知道有超过一半的处理器仍然是好的。你可以向一个处理器询问另一个处理器是好的还是坏的。一个好的处理器总是说真话，一个坏的处理器总是说假话。用n-2次询问找出一个好的处理器。
答案：给处理器从1到n标号。用符号a→b表示向标号为a的处理器询问处理器b是不是好的。首先问1→2，如果1说不是，就把他们俩都去掉（去掉了一个好的和一个坏的，则剩下的处理器中好的仍然过半），然后从3→4开始继续发问。如果1说2是好的，就继续问2→3，3→4，……直到某一次j说j+1是坏的，把j和j+1去掉，然后问j-1 → j+2；或者从j+2 → j+3开始发问，如果前面已经没有j-1了（之前已经被去掉过了）。注意到你始终维护着这样一个"链"，前面的每一个处理器都说后面那个是好的。这条链里的所有处理器要么都是好的，要么都是坏的。当这条链越来越长，剩下的处理器越来越少时，总有一个时候这条链超过了剩下的处理器的一半，此时可以肯定这条链里的所有处理器都是好的。或者，越来越多的处理器都被去掉了，链的长度依旧为0，而最后只剩下一个或两个处理器没被问过，那他们一定就是好的了。另外注意到，第一个处理器的好坏从来没被问过，仔细想想你会发现最后一个处理器的好坏也不可能被问到（一旦链长超过剩余处理器的一半，或者最后没被去掉的就只剩这一个了时，你就不问了），因此询问次数不会超过n-2。

17. 一个圆盘被涂上了黑白二色，两种颜色各占一个半圆。圆盘以一个未知的速度、按一个未知的方向旋转。你有一种特殊的相机可以让你即时观察到圆上的一个点的颜色。你需要多少个相机才能确定圆盘旋转的方向？
答案：你可以把两个相机放在圆盘上相近的两点，然后观察哪个点先变色。事实上，只需要一个相机就够了。控制相机绕圆盘中心顺时针移动，观察颜色多久变一次；然后让相机以相同的速度逆时针绕着圆盘中心移动，再次观察变色的频率。可以断定，变色频率较慢的那一次，相机的转动方向是和圆盘相同的。

Read full article from 分享一些有趣的面试智力题（下） | Matrix67: The Aha Moments

分享一些有趣的面试智力题（上） | Matrix67: The Aha Moments

偶然进了这个页面，看到几个原来没见过的面试智力题。顺带也翻译一些比较少见、可能有人没见过的题目写在这里。有几个题目在国内流传相当广，什么n个人怎么分饼最公平，屋里的三个灯泡分别由哪个开关控制，三架飞机环游世界，用火柴和两根绳子测量45分钟之类的题目，火星得已经可以考古了，这里就不再说了。个别题目本Blog原来有过详细的介绍，这里也不再提了。

1. 考虑一个双人游戏。游戏在一个圆桌上进行。每个游戏者都有足够多的硬币。他们需要在桌子上轮流放置硬币，每次必需且只能放置一枚硬币，要求硬币完全置于桌面内（不能有一部分悬在桌子外面），并且不能与原来放过的硬币重叠。谁没有地方放置新的硬币，谁就输了。游戏的先行者还是后行者有必胜策略？这种策略是什么？
答案：先行者在桌子中心放置一枚硬币，以后的硬币总是放在与后行者刚才放的地方相对称的位置。这样，只要后行者能放，先行者一定也有地方放。先行者必胜。

2. 用线性时间和常数附加空间将一篇文章的单词（不是字符）倒序。
答案：先将整篇文章的所有字符逆序（从两头起不断交换位置相对称的字符）；然后用同样的办法将每个单词内部的字符逆序。这样，整篇文章的单词顺序颠倒了，但单词本身又被转回来了。

3. 用线性时间和常数附加空间将一个长度为n的字符串向左循环移动m位（例如，"abcdefg"移动3位就变成了"defgabc"）。
答案：把字符串切成长为m和n-m的两半。将这两个部分分别逆序，再对整个字符串逆序。

4. 一个矩形蛋糕，蛋糕内部有一块矩形的空洞。只用一刀，如何将蛋糕切成大小相等的两块？
答案：注意到平分矩形面积的线都经过矩形的中心。过大矩形和空心矩形各自的中心画一条线，这条线显然把两个矩形都分成了一半，它们的差当然也是相等的。

    5. 一块矩形的巧克力，初始时由N x M个小块组成。每一次你只能把一块巧克力掰成两个小矩形。最少需要几次才能把它们掰成N x M块1×1的小巧克力？
    答案：N x M �C 1次显然足够了。这个数目也是必需的，因为每掰一次后当前巧克力的块数只能增加一，把巧克力分成N x M块当然需要至少掰N x M �C 1次。

    6. 如何快速找出一个32位整数的二进制表达里有多少个"1″？用关于"1″的个数的线性时间？
    答案1（关于数字位数线性）：for(n=0; b; b >>= 1) if (b & 1) n++;
    答案2（关于"1″的个数线性）：for(n=0; b; n++) b &= b-1;

7. 一个大小为N的数组，所有数都是不超过N-1的正整数。用O(N)的时间找出重复的那个数（假设只有一个）。一个大小为N的数组，所有数都是不超过N+1的正整数。用O(N)的时间找出没有出现过的那个数（假设只有一个）。
答案：计算数组中的所有数的和，再计算出从1到N-1的所有数的和，两者之差即为重复的那个数。计算数组中的所有数的和，再计算出从1到N+1的所有数的和，两者之差即为缺少的那个数。

8. 给出一行C语言表达式，判断给定的整数是否是一个2的幂。
答案：(b & (b-1)) == 0

9. 地球上有多少个点，使得从该点出发向南走一英里，向东走一英里，再向北走一英里之后恰好回到了起点？
答案："北极点"是一个传统的答案，其实这个问题还有其它的答案。事实上，满足要求的点有无穷多个。所有距离南极点1 + 1/(2π)英里的地方都是满足要求的，向南走一英里后到达距离南极点1/(2π)的地方，向东走一英里后正好绕行纬度圈一周，再向北走原路返回到起点。事实上，这仍然不是满足要求的全部点。距离南极点1 + 1/(2kπ)的地方都是可以的，其中k可以是任意一个正整数。

10. A、B两人分别在两座岛上。B生病了，A有B所需要的药。C有一艘小船和一个可以上锁的箱子。C愿意在A和B之间运东西，但东西只能放在箱子里。只要箱子没被上锁，C都会偷走箱子里的东西，不管箱子里有什么。如果A和B各自有一把锁和只能开自己那把锁的钥匙，A应该如何把东西安全递交给B？
答案：A把药放进箱子，用自己的锁把箱子锁上。B拿到箱子后，再在箱子上加一把自己的锁。箱子运回A后，A取下自己的锁。箱子再运到B手中时，B取下自己的锁，获得药物。

11. 一对夫妇邀请N-1对夫妇参加聚会（因此聚会上总共有2N人）。每个人都和所有自己不认识的人握了一次手。然后，男主人问其余所有人（共2N-1个人）各自都握了几次手，得到的答案全部都不一样。假设每个人都认识自己的配偶，那么女主人握了几次手？
答案：握手次数只可能是从0到2N-2这2N-1个数。除去男主人外，一共有2N-1个人，因此每个数恰好出现了一次。其中有一个人(0)没有握手，有一个人(2N-2)和所有其它的夫妇都握了手。这两个人肯定是一对夫妻，否则后者将和前者握手（从而前者的握手次数不再是0）。除去这对夫妻外，有一个人(1)只与(2N-2)握过手，有一个人(2N-3)和除了(0)以外的其它夫妇都握了手。这两个人肯定是一对夫妻，否则后者将和前者握手（从而前者的握手次数不再是1）。以此类推，直到握过N-2次手的人和握过N次手的人配成一对。此时，除了男主人及其配偶以外，其余所有人都已经配对。根据排除法，最后剩下来的那个握手次数为N-1的人就是女主人了。

Read full article from 分享一些有趣的面试智力题（上） | Matrix67: The Aha Moments

砝码称重问题，因式分解有妙用 | 科学人 | 果壳网科技有意思

如果天平两端都允许放砝码，并且假定所有的砝码都是整数克。为了称出从 1 克到 40 克 所有整数克 的物品，最少需要几个砝码？

感兴趣的读者不妨自己先试着想想，再往下看。

秘密在于 3 的幂

说起来这个问题历史还算是挺悠久的。据《数学游戏与欣赏》（ [英] 劳斯・鲍尔 [加] 考克斯特著，杨应辰等译），这个问题被称作巴协 (Bachet) 砝码问题；而据《数学聊斋》（王树禾著），该问题至少可追溯到 17 世纪法国梅齐里亚克 (Meziriac, 1624) 。他们给出的答案是：

Read full article from 砝码称重问题，因式分解有妙用 | 科学人 | 果壳网科技有意思

Apache Eagle――eBay开源分布式实时Hadoop数据安全方案-CSDN.NET

日前，eBay公司隆重宣布正式向开源业界推出分布式实时安全监控引方案―― Apache Eagle，该项目已正式加入Apache 称为孵化器项目。Apache Eagle提供一套高效分布式的流式策略引擎，具有高实时、可伸缩、易扩展、交互友好等特点，同时集成机器学习对用户行为建立Profile以实现实时智能实时地保护Hadoop生态系统中大数据的安全。

背景

随着大数据的发展，越来越多的成功企业或者组织开始采取数据驱动商业的运作模式。在eBay，我们拥有数万名工程师、分析师和数据科学家，他们每天访问分析数PB级的数据，以为我们的用户带来无与伦比的体验。在全球业务中，我们也广泛地利用海量大数据来连接我们数以亿计的用户。

近年来，Hadoop已经逐渐成为大数据分析领域最受欢迎的解决方案，eBay也一直在使用Hadoop技术从数据中挖掘价值，例如，我们通过大数据提高用户的搜索体验，识别和优化精准广告投放，充实我们的产品目录，以及通过点击流分析以理解用户如何使用我们的在线市场平台等。

Read full article from Apache Eagle――eBay开源分布式实时Hadoop数据安全方案-CSDN.NET

面试经验分享之智力题 - Blog of 太极儒

我在算法工程师面试中遇到的智力题主要是指涉及到一些数学计算、证明的题目，基本是中小学奥数题。喜欢问这类问题的主要有互联网创业公司或外企，招收数值策划的游戏公司，当然，更多的是金融、投资相关的企业。从题目类型上分，有排列组合题、概率题等。

题目介绍

题目一：给定天平，问要称重1-N N种不同质量，最少需要多少种砝码？

1）砝码只允许放在天平的一端；

2）砝码可以放在天平的两端。

解答：

只允许放在一边的情况，开始自己以为是斐波那契数列，不过显然数列生成方式里存在冗余（1+2=3）。1、2 肯定是最基本的数字，新添加的砝码质量应该是原砝码集合所能称量的最大质量加一，如此生成的数列就是2的幂次，1，2，4，……想到正整数二进制表达的唯一性，应该是不存在冗余的。可表示性是有了，对于1-N N种不同的质量，最少需要 $\left\lceil \log _{ 2 }{ (N+1) } \right\rceil$ 种不同的砝码，那是不是最少的呢？这种做法没有冗余，且表示范围是砝码的排列组合（每一个砝码可用可不用），应该就是最少了的，不过这不是严格证明。
允许放在两边的情况，1、3是最基本的，因为 2 可以用 3-1 表达，新添加砝码的质量应该满足的条件是原砝码集合所能称量的最大质量加上这个最大质量的下一个质量。这种构造方法同样没有冗余，且表示范围是砝码的排列组合（每一砝码可加、可减、可不用，再排除掉和非正数的情况），所以应该也是最少的。按照这个思路生成的数列就是3的幂次，1，3，9，27……可以用数学归纳法证明如下。

Read full article from 面试经验分享之智力题 - Blog of 太极儒

面试经验分享之数据结构、算法题 - Blog of 太极儒

在正式介绍题目和准备方法之前，有两点需要说明，

Google 和 Facebook 这类对算法有很高要求的公司的在线测试我没有参加过（不过在牛人内推帮助下有过面试体验……），这超出了我目前的编码能力范围，网上有不少拿到 Google、Facebook offer 的经验总结文章，可以移步观赏；
前段时间在微博上又看到有人说自己把 leetcode 刷了好几遍，不过一些转发评论者觉得， IT 公司面试中的算法考察没有价值，一来工作里用不太上，二来把程序员素质考察搞成了应试教育，他们认为更重要的是应聘者的工程能力。遇到这样的讨论，我一般喜欢和一把稀泥。若干年前， Google、微软的面试题让大家眼前一亮，觉得能选拔出个性十足的聪明人来，不过随着大家对这类题目的适应，可能选拔出来的人也在趋同，至少很多人都会在面试前用心准备，据报道 Google 最近也是放弃了这类面试题目。没有什么一劳永逸、一成不变的考查方式，毕竟面试是人和人之间的动态"较量"。不要贪恋算法的奇技淫巧，也不要因为题目筛选力度的衰减而否定考察初衷。面试不仅是考验求职者，也同样在考验面试官，如果问的都是老题儿，那本山大叔肯定都会抢答了。

Read full article from 面试经验分享之数据结构、算法题 - Blog of 太极儒

Lambda Architecture » λ lambda-architecture.net

What is the Lambda Architecture?

Nathan Marz came up with the term Lambda Architecture (LA) for a generic, scalable and fault-tolerant data processing architecture, based on his experience working on distributed data processing systems at Backtype and Twitter.

The LA aims to satisfy the needs for a robust system that is fault-tolerant, both against hardware failures and human mistakes, being able to serve a wide range of workloads and use cases, and in which low-latency reads and updates are required. The resulting system should be linearly scalable, and it should scale out rather than up.

Here's how it looks like, from a high-level perspective:

LA overview

All data entering the system is dispatched to both the batch layer and the speed layer for processing.
The batch layer has two functions: (i) managing the master dataset (an immutable, append-only set of raw data), and (ii) to pre-compute the batch views.
The serving layer indexes the batch views so that they can be queried in low-latency, ad-hoc way.
The speed layer compensates for the high latency of updates to the serving layer and deals with recent data only.
Any incoming query can be answered by merging results from batch views and real-time views.

Read full article from Lambda Architecture » λ lambda-architecture.net

Apache Storm: The Big Reference | Parse.ly

In the last year, a flurry of digital documentation has been released about Storm, as the project gained traction in the commercial community. The project also entered Apache as a formal "incubating" project.

So, what is Apache Storm?

Apache Storm is a free and open source distributed realtime computation system. Storm makes it easy to reliably process unbounded streams of data, doing for realtime processing what Hadoop did for batch processing. Storm is simple, can be used with any programming language, and is a lot of fun to use! Storm has many use cases: realtime analytics, online machine learning, continuous computation, distributed RPC, ETL, and more.

Storm is fast: a benchmark clocked it at over a million tuples processed per second per node. It is scalable, fault-tolerant, guarantees your data will be processed, and is easy to set up and operate. Storm integrates with the queueing and database technologies you already use. A Storm topology consumes streams of data and processes those streams in arbitrarily complex ways, repartitioning the streams between each stage of the computation however needed.

Read full article from Apache Storm: The Big Reference | Parse.ly

超酷的裸眼 3D 技术，谷歌没有白投 5 亿美刀 - 博客 - 伯乐在线

2014年10月，谷歌领投视觉技术创业公司 Magic Leap 5.42 亿美元。

在接受《华尔街日报》采访时，Magic Leap CEO 阿伯维茨表示，Magic Leap 将成为一种新界面，能替代计算机显示器和智能手机屏幕。该公司开发的首款产品是眼镜式可穿戴计算设备，硬件和软件均为该公司自主设计。Magic Leap的视觉技术能将准确的图像投射至眼睛，从而使用户看到虚拟的3D物体，创造类似真实世界的环境。换句话说，这款设备能"欺骗"大脑，使大脑认为看到的虚拟图像是真实世界。

大部分虚拟现实设备都采用了立体成像技术，即向两只眼睛投射不同的图像，从而形成立体感。但这种技术会给用户造成眩晕，尤其是当用户头部运动与虚拟世界的运动不同步时。阿伯维茨则表示，该公司的技术不会引起眩晕。

他认为，Magic Leap的技术有着更深远的意义，例如带来全新的电影和游戏形式，创造病人与医生进行互动的新方式，以及作为一种新的远程通信工具。阿伯维茨还计划给这种设备加入更多的感官体验，例如触觉。（摘自新浪）

不过，在拿到融资后，并未听到关于其产品的消息，迄今为止，外界仍然对 Magic Leap 知之不多，只知道它的技术可以在现实场景中显示全息景象，当然用户必须佩戴特殊的眼镜才能看到全息景象。

Read full article from 超酷的裸眼 3D 技术，谷歌没有白投 5 亿美刀 - 博客 - 伯乐在线

不少程序员都会碰到的三个面试题 - 博客 - 伯乐在线

对于算法面试问题是否有效一直饱受争议。然而，代码编写问题有时候能够很好筛选人才。在我们的例子中：

这些问题是"CS101"水平的；
我们相信一个优秀的开发者需要能够做出好的决定，并且这种好的决定是基于对有多少个复杂系统在交互的深刻理解上。如果一个开发者不能反转一个字符串，那么他们又怎么可能理解大型客户端面临软件的性能含义？

诚然，参与我们CS02课程的中学生都很聪明（其中一个还是美国计算机奥林匹克对队员）。然而，在对大型软件公司（如微软、亚马逊、谷歌等）的多年采访后，我们发现专业的开发者们并没有比我们的职业顾问人员牛多少。

Read full article from 不少程序员都会碰到的三个面试题 - 博客 - 伯乐在线

程序员摆脱疲劳的 11 个建议 - 博客 - 伯乐在线

我们的行业压力大、人手少、节奏快，所以有时候很容易让人感到倦怠和失望。程序员总是觉得很累，烦躁甚至是沮丧。

这里有一份快速指南，能够克服可怕的"程序员疲劳"：

吃一顿丰盛的早饭

高科技产业的很多人都是熬夜到凌晨 3 点，很晚才起床，不吃早饭就冲到办公室。或者随便在路边脏兮兮的早点摊，买点难吃和恶心的熏肉三明治。早餐是一天中最重要的一餐，这是真的。而且不仅仅是要吃早餐，早餐吃什么也很重要。尽量吃点富含蛋白质的食物，比如豆类、牛油果和全麦面包等。不要吃白面包和早餐麦片，它们都富含糖类，会导致中午血糖升高容易犯困。

按时睡觉

要尽量保证 9 个小时的睡眠，如果你能睡到 7 或 8 个小时，那你做得不错。人们很容易就认为睡觉是在浪费时间，但从长期来看，你坐在那里，眼睛酸痛，双眼茫然地盯着屏幕，这样会更加浪费时间。拼命想抓住支离破碎的思路，而那正是程序员赖以生存的。

不要吃垃圾食品

这条要联系第一条，但这个范围更广。如果你想摄入碳水化合物，含糖的零食特别是含糖饮料，可以很快让你吃饱，但你在这一天剩下的时间都会觉得非常糟糕。你可以吃一些绿叶蔬菜，水果以获取能量…… 如果你实在想爽一下，那就坚持喝美式咖啡吧（当然是无糖）。

喝水

当你脱水时，你的身体会变得懒散和缓慢，因为它要应付更多的基本机能。当你脱水时，身体会产生应激激素，比如皮质醇，这会使你的能量水平衰竭，并会导致"脑雾"（译者注：脑雾是大脑难以形成清晰思维和记忆的现象）。据说当工人脱水时，生产力会下降多达12%。

和你的老板聊聊天

如果你正在纠结或是感觉生产力较低，那么就和你老板聊一聊，看看有没有什么明显的事情可以做。如果你一直做你不喜欢的事情，或者是不擅长的事情，你可能需要换一个新的项目做一段时间。如果你是后端开发人员，但你发现自己厌倦了像素，不要勉强自己。你的雇主也会希望用人所长。

更好地管理时间

如果你发现自己不得不在项目之间游走，或是每个小时都要切换代码库甚至是编程语言。又或者你发现自己总是在熬夜赶进度。请你每天先花 10 分钟写下待办事项列表。从那些"速效方案"入手吧。我们往往会下意识地担心那些被我们拖延很久的琐碎问题，但它们已经在那里了。如果一天开始的时候，你能以解决几个这样的问题……你在这一天剩下的时间都会感觉根本停不下来，压力也会小很多。

定期休息

这项似乎是显而易见的，但干我们这行的都想当英雄，从开始工作到结束都不休息，午餐也工作，好像谁休息得最少就能拿奖牌一样。长期来看，如果你总是试着"竭力工作"，你的效率会降低。你的思路会变得模糊，你自己就会开始焦虑和不开心。看一场国际足联的比赛，喝一杯咖啡，去厕所坐上一个小时。不论做什么，只要让你的大脑放松一下。编程很难，它是对脑力的透支。你不必去健身房，也不用长期固定训练，只需要在座位之间稍事休息一下，否则会有肌肉萎缩的风险。这对你的大脑而言并没有什么不同。

锻炼身体

另一个相当明显的方法。要努力养成经常运动的习惯，即使是快步走也很好，特别是在早晨你还没有开始工作的时候。运动会释放内啡肽，它可以缓解压力，让你体内循环着更多的氧气，让你能更容易集中注意力。

编程之余休息一下

如果你像我一样，你可能以软件和技术为生。也许你现在在这个窗口后面就正开着 Vim 呢。那就太好了，这关系到你是成为普通的程序员，还是一位受人尊敬的工程师。但有时你也需要停下来做些别的事情。人说小别胜新婚。有时我在周末离开时不会带笔记本，我能想到的就是写代码。但我还是把它抛之脑后，花时间和朋友家人去吃饭，看电视或者……随便喝点小酒。但当我周一早上重新回到办公室时，忍不住要赶紧开始工作。周五沉闷又恼人的问题，突然又变成一个有趣的挑战了。

正念

这是一个时髦的词，它已经在科技行业流行一段时间了。一天开始，即使只是 10 分钟的冥想，都会让你在一整天里更平静和更专注。

伯乐在线小编注：正念意指以特殊的方式专注：刻意、当下、不加判断，这种专注可滋养出更多正知、清明智慧，并更能接受当下的实相。

不要做加班的英雄

除非你很讨厌你的生活，不要每晚都呆到 11 点，做没有什么实质性工作给管理者留下印象，或是从同事中脱颖而出。这没什么大不了的，也不聪明，而且还会耗尽你的精力。如果你的经理希望你每天工作到很晚，结果影响到你的工作质量，那就是他们营造了一个不健康的工作环境。如果是自己主动，那就要警惕长期的后果。

结语

治愈程序员倦怠没有灵丹妙药，我上面提到的习惯也不是很容易就能养成的。它不会在一夜之间发生。所以从小事开始，一步一步来，如果需要可以做些记录。试着从长远考虑，而不是只盯着下一个目标。如果问题依然存在，考虑寻求专业帮助。没什么丢人的！

Read full article from 程序员摆脱疲劳的 11 个建议 - 博客 - 伯乐在线

G. Polya, How to Solve It.

UNDERSTANDING THE PROBLEM

First. You have to understand the problem.
What is the unknown? What are the data? What is the condition?
Is it possible to satisfy the condition? Is the condition sufficient to determine the unknown? Or is it insufficient? Or redundant? Or contradictory?
Draw a figure. Introduce suitable notation.
Separate the various parts of the condition. Can you write them down?

DEVISING A PLAN

Second. Find the connection between the data and the unknown. You may be obliged to consider auxiliary problems if an immediate connection cannot be found. You should obtain eventually a plan of the solution.
Have you seen it before? Or have you seen the same problem in a slightly different form?
Do you know a related problem? Do you know a theorem that could be useful?
Look at the unknown! And try to think of a familiar problem having the same or a similar unknown.
Here is a problem related to yours and solved before. Could you use it? Could you use its result? Could you use its method? Should you introduce some auxiliary element in order to make its use possible?
Could you restate the problem? Could you restate it still differently? Go back to definitions.
If you cannot solve the proposed problem try to solve first some related problem. Could you imagine a more accessible related problem? A more general problem? A more special problem? An analogous problem? Could you solve a part of the problem? Keep only a part of the condition, drop the other part; how far is the unknown then determined, how can it vary? Could you derive something useful from the data? Could you think of other data appropriate to determine the unknown? Could you change the unknown or data, or both if necessary, so that the new unknown and the new data are nearer to each other?
Did you use all the data? Did you use the whole condition? Have you taken into account all essential notions involved in the problem?

CARRYING OUT THE PLAN

Third. Carry out your plan.
Carrying out your plan of the solution, check each step. Can you see clearly that the step is correct? Can you prove that it is correct?

Looking Back

Fourth. Examine the solution obtained.
Can you check the result? Can you check the argument?
Can you derive the solution differently? Can you see it at a glance?
Can you use the result, or the method, for some other problem?

Read full article from G. Polya, How to Solve It.

Problem Solving Strategies for math

Learning how to solve problems in mathematics is knowing what to look for. Math problems often require established procedures and knowing what and when to apply them. To identify procedures, you have to be familiar with the problem situation and be able to collect the appropriate information, identify a strategy or strategies and use the strategy appropriately. G. Polya wrote a book titled 'How To Solve It' in 1957. Many of the ideas that worked then, continue to work for us now. The steps below are very similar to those expressed in Polya's book.

Problem solving requires practice! The more your practice, the better you get.
Practice, practice, practice.

Problem Solving Plan in 4 Steps:

1. Clues:

Read the problem carefully.
Underline clue words.
Ask yourself if you've seen a problem similar to this one. If so, what is similar about it?
What did you need to do?
What facts are you given?
What do you need to find out?

2. Game Plan:

Define your game plan.
Have you seen a problem like this before?
Identify what you did.

Read full article from Problem Solving Strategies for math

Find the maximum subarray XOR in a given array - GeeksforGeeks

Find the maximum subarray XOR in a given array

Given an array of integers. find the maximum XOR subarray value in given array. Expected time complexity O(n).

Examples:

Input: arr[] = {1, 2, 3, 4}  Output: 7  The subarray {3, 4} has maximum XOR value    Input: arr[] = {8, 1, 2, 12, 7, 6}  Output: 15  The subarray {1, 2, 12} has maximum XOR value    Input: arr[] = {4, 6}  Output: 6  The subarray {6} has maximum XOR value

We strongly recommend you to minimize your browser and try this yourself first.

A Simple Solution is to use two loops to find XOR of all subarrays and return the maximum.

Read full article from Find the maximum subarray XOR in a given array - GeeksforGeeks

除草 - nblt's Blog

SRM 503 DIV1 500pt ( 求期望题.贪心，枚举，概率计算 ) 答案分成两点之间的答案，再组合数统计即可。注意dist相同的情况，可以规定优先级。。先连city，再按顺序连village，这样就很方便了。。ll没开怎么死都不知道！！

SRM 507 DIV1 900pt ( dp+组合数学基础 ) 直接暴力dp即可

SRM 495 DIV1 975pt(数学， dp）一开始不会，可耻的去膜题解，然后发现了诡异的转移。。看了很久没看懂，YY了很久，终于在一个晚上想明白了。。我是个傻逼。。。题意是给你高度为H的楼房，让你用n个电梯覆盖，覆盖是这样的，保持电梯的相对位置不变，不遗漏的覆盖完，问方案数。如H=8,N=4 12123434。然后令f(H,N)表是前两个是不同的电梯覆盖，g(H,N)表示是相同的电梯覆盖，然后观察序列，发现1-N序列连续的块大小是定值，然后就f(H,N)就枚举块的大小,有f(H,N) = sigma g(H/d,N/d) (d>1, d|N) 现在考虑g(H,N)的转移,有g(H,N) = f)H,H/N) 可以这样理解，着相当于将所有的1由1-H/N替代，由于前两个都是1，这样的方案对应一个前两个是不同的电梯覆盖的方案。这样就可以了。:-D

TCO'10 Wildcard Round 500pt

题意：给你一堆带符号的卡片包含（+,-,*），随机抽取成排列，求期望表达式的值

注意到每一个非乘号后面均是等价的，所以分开来算，只要把所有非乘号的卡片的和加起来再乘上每一段的期望。而每一段的期望等价于开头全是乘号的期望积，枚举连续的K个，简单统计即可。很拙，思考了很久。

SRM 498 DIV1 1000pt

题意:求从(0,0)走到(Tx,Ty)且步长不超过(Mx,My)且有一些bad走法(dx=dy且为10倍数)问方案数

没想出来，看题解的。容斥走了几步坏的,注意到步子是可以交换的，然后dp再组合数统计没了。。感觉很厉害

TCO'10 Semifinal 1 950pt

一开始想残了，然后YY了很久才搞出来。。比较恶心的dp.枚举再前后dp一遍即可

SRM 522 DIV1 1050pt

题意：给你一些y[i]代表点(i,y[i])，每一次可以删除以两个点为对角线矩形内的点，问最终点剩余的可能方案

一开始没想法，其实这题是很好想的。首先我们观察最终留下的状态，那么显然是左右端点以及ymax与ymin的点，唯一有变化的是与左右y坐标相同的一些点，简单dp即可。

SRM 521 DIV1 500pt

题意：给你一些点，可以选择边长在lown到highn之间选择正方形去覆盖，问可能的集合数

显然不会太多，然后枚举左上与右下，简单判即可

SRM 481 DIV1 500pt

题意：给你一些人的任务，同一个人有多个任务。求安排任务顺序，使得平均等待时间最小。只有一台机器，且在最优方案中等概率选择，问每个任务完成的期望

每个人的任务总是连在一起的，简单计算即可。

SRM 521 DIV1 1000pt

题意：一个烟囱是由4个1*2的砖垒成一层，问你垒N层的方案数（只有下面的堆玩才能堆上面的）

一开始想不出状态定义，感觉很复杂，后来开了一下脑洞，只要考虑放第i层第一个后前两层的状态，只有4种情况，转移矩阵系数挺烦的，暴力状压算即可。

SRM 520 DIV1 500pt

sb背包

SRM 520 DIV1 1000pt

题意：给你一些哪些人cha过人以每个人被cha的转态，询问cha不同的序列数。每个人仅cha一次，而且被cha以后不会去cha别人。

非常神。一开始没有什么想法，去膜题解。好巧妙！当你搞不清关系时，可以列表，转换成形象的图形。而且显然可以将人分类。先放既cha人又被cha的，再放其他人。dp+组合排列

SRM 519 DIV1 600pt

ac自动机+dp

SRM 519 DIV1 900pt

枚举2,3相互搞的数量，再剩下与5,7匹配即可。注意怎么开数组（vector)

SRM 518 DIV1 500pt

貌似随便写了个贪心过了

SRM 518 DIV1 1000pt

本来是fwt的，但不会，学习了简单易懂的分治乘，而且复杂度是NlogN的。

SRM 517 DIV1 600pt

题意：操作i可以是a[i]与a[i+1]交换，给你一个目标排列，问你用1-i-1的i-1个操作排列使1--i-1变成目标排列，问排列方案数

很考思维，注意到操作i之前左右的数值不会交换，令f[i][j]为将i--j搞成有序的方案数，那么枚举最后一个操作，就变成了两个子问题。关键是要发现dp子问题的性质。

SRM 517 DIV1 900pt

题意：给你一个字符board，每次可以染一行或一列。问你最小次数

首先这种问题一般方法是先枚举一下，再推出一些信息。可以证明肯定有一行或一列不用染（反正，如果都染，那么第一次的会被全部覆盖),然后就知道了一行或一列的染色，再看不合法的点肯定让另一维染，搞出拓扑图判断。注意如果行列颜色都一样就没有限制关系！！

SRM 516 DIV1 500pt

简单的贪心

SRM 515 DIV1 550pt

题意：给你一些人到达店买剑的时间，价钱以及概率，每个人最多买一把剑，问你最多买K把剑的最优期望

可以dp[mask][i][j]表示mask的到过店，有i把剑，时间为t，dp即可。我觉的最难的是他告诉你每个时间到达店的概率，这样没法dp，而我们能做到的dp是用p[i]表示到以及(1-p[i])表示不到的概率进行转移，所以要把概率转一下，这点非常非常关键！！

SRM 515 DIV1 1000pt

题意：给你N*M的棋盘，有一些障碍点，三种人分别有他们的起始位置，各部相同，等概率出现在对应的位置上，三种人到达同一点，求走最短路的期望，两种人数<=20(N,M<=50)

一开始感觉很困难，两种人显然是要枚举的，但第三种人感觉很难再N*M的复杂的内求出。看了题解之后，忽然感觉很简单，N*M的复杂度只能BFS一遍，那么就考虑一种构图方法，使得求出的第三种人的距离为三个人最短路的答案，那么就很简单了，先枚举前两个人，再枚举三个人的聚集地点，然后对于每种前两个人到达聚集点的距离建一个点，距离i向距离i+1连边，然后每个距离向合法的到达点连边，再跑一遍BFS即可。很巧妙，关键是要想到可以直接BFS最终的距离和。

SRM648 DIV1 850pt

题意：求N个点K个桥带标号的图的个数

好难，首先图可以分成一个一个联通块背包do，然后一个联通块可以将桥拆掉变成若干个双联通分量，由矩阵树定理可得：N个带标号的点S个联通块(大小为mi)加S-1条边使图联通的方案数为N^(S-2)*pi(ai)。然后就算N个点的双联通分量有几个，可以先算出所有的联通图数量，再减去1-N-1座桥的图的数量。

SRM 510 DIV1 500pt

题意：仅有4,7构成的数是lucky number，A从[a,b]中选出连续的L1个，B从A选出的中选出连续的L2个。A要最大化lucky number的数量，B要最小化lucky number的数量，问最终结果(a,b<=10^10)

一开始很乱，感觉直接贪心边界十分不好处理，情况也非常多。然后去看了题解，看了将B从x选起的结果用F(X)表示出来，立马就懂了，可以发现函数值是连续的，就可以分成一些段搞了。然后枚举答案，看是否存在L1长度连续的即可。关键思路是将复杂的东西具体化，暴力化，用函数表示出来，就很显然了。

SRM 510 DIV1 1000pt

题意：仅有4,7构成的数是lucky number，给你N(N<=1e16)，问你有多少D是的ND进制下每一位是lucky number

首先方案不会太多，可以考虑枚举。但怎么枚呢？首先考虑假如有很多位那么D应很小，爆枚即可。当有2-3位时，看似很难枚，但由于数字只能是4,7构成，爆搜一下发现发难数都很少，check一下就可以了。关键是要先转化到位数很少的情况，再考虑爆枚。

SRM 658 DIV1 850pt

二分图最大匹配，然后判一判即可

SRM 658 DIV1 650pt

题意：给你N个怪物(N<=20),每个怪的血值(<=60)，每次attck可以选择三个，分别扣血1,3,9滴，问你最少几次

首先可以二分答案，然后呢,发现如果选完3,9，剩下的只能选一到满，令dp[o][k][l]表示搞到第i个人3,9用了j,k个的最少1个数。dp即可。关键在于发现1取到满即可的性质

TCO Round3 2A 1000pt

题意：问你A^B有多少种不同的数，1<=A<=1e9, 1<=B<=1e9

首先可以将每个A^X表示成(r^k)^X,其中r为不能表示成更小的指数幂形式，那么可以知道k<=30，故暴力枚举k，先考虑如何统计最大次幂为k的r有几个，可以考虑容斥，答案等于sigma(i,mu[i]*这段区间中能表示成i次幂的数的个数)。

好，然后考虑对一个r不同的方案数，那么可以转换成k*X的方案数。这个怎么算呢，首先观察到k很小，考虑分段，对于(i*X,(i+1)*X]这段的答案，显然只有i+1到k乘才会合法，而对于i能覆盖所有i的倍数覆盖的点，那么考虑容斥，只要考虑哪些不构成倍数关系的数即可，这样最多只有15个左右，就可以了。关键是要想到优化容斥，直接容斥是2^30次，而分段则可以优化很多。

1的情况要特殊考虑。

TCO Round3 2A 600pt

题意：一个Magic Matrix定义为所有行和列的和的最后一位相同。每个格子只能填0-9.问你在N(<=1)个格子已填的基础上，有多少种不同的方案。

首先，如果N很大，那么可以将空的一行和一列交换到最后，这样可以直接算出！！

如果N很小，暴力搞死消元。关键是要想到可以交换的性质。

SRM578 DIV1 1000pt

题意：给你N个节点的树(N<=50),让你割掉一些边形成若干个联通子树，选出两棵子树，使它们同构。问最大点数

好难！首先可以考虑对于两棵有根树该怎么办，可以递归算出两个儿子分别匹配的答案，然后最优匹配即可。

然后可以枚举一条边删掉，然后枚举两个联通快的根，统计答案取max

关键是想到对于两棵有根树该怎么做。可以递归得到儿子答案，在最优匹配合并。/(ㄒoㄒ)/~~

SRM578 DIV1 500pt

题意长度为N(<=300)的线段上每个点可能有fox，现在给你一些条件，形如[L,R]这段区间至多有两个fox。问方案数

首先观察N的范围，考虑N^3的dp。令dp[i][j]表示i,j上有为相邻fox的方案数。这道题关键是用到最多两个的性质，直接上两维状态表示即可。O(∩_∩)O

TCO13 Semifinal1 550pt

题意：给你一个DAG的拓扑序列，一个DAG序列生成的方式是等概率随机当前入度为0的集合中的一个点加到序列。问你这个DAG中有A->B这条边的概率是多少

可以从后往前dp，设dp[i][j]表示到第i个点，后面的点是不是入度为0(用j表示一个二进制)的概率。直接算即可。最后必须有这条边的概率与所有概率除一除即可 O(∩_∩)O

SRM 509 DIV1 1000pt

题意：给你一个凸多边形，以及内部的N个点，每个点分配周长的1/N，问你内部的点到分配的点的最大值的最小值是多少？

二分，然后怎么判，先枚举每条线段，与每个圆作交，求出每个交点，在对每一段建点，跑网络流看是否满流即可。判线段与圆的交，设交点为X+w*d，d为直线向量，这样比较方便。注意eps。关键是讲复杂的交法转换成每一条边与每一个圆的交，算计技巧以很重要。/(ㄒoㄒ)/~~

SRM 507 DIV1 500pt

题意：给你Ns个1*1*1的方块和Nb个L*L*L个方块，用体积最小的长方体装下这些方块，求最小体积(要求平行）

一开始不会做，后来抱着试试看的心态，写了L*L*x，发现过了4个点，然后就发现答案最大值最多加L*L-1，然后写了个爆枚体积，分解因数判断的。。

后来看了题解，发现傻逼了。。由于题目中给出体积小于int，故直接枚举最短边，次短边在算第三条边即可。。关键是想到题解很小，而且爆枚两个最小边的复杂度很小。。。^_^

Read full article from 除草 - nblt's Blog

[转]Topcoder好题推荐 by 白衣少年 - 天亮说晚安 - 博客频道 - CSDN.NET

白衣少年

简介：
白衣少年，本科毕业只花了三年同时惊人一跳考入中国科学院软件所。现为微软中国STC员工。他的常用id为白衣少年、白衣少年2012、kyo_key。
白衣少年成名于Topcoder比赛，他从2007年开始参加TC，几乎坚持场场必刷，非常刻苦。其中在2011年，获得了Algorithm Coder of the Month。除了TC，白衣少年还活跃在CF、百度之星、GCJ等比赛。他参加了2011年的百度之星比赛，成功杀入决赛，获得了第六名以及和百度CEO李彦宏共进晚餐的机会。

在ACM_DIY中，白衣少年是群成员的人生导师。他精于把妹，经常在群中开办虚拟讲座，交流其丰富的把妹经验，并曾经亲自带领部分成员进行搭讪实践。

---------------------------------------------------------------------------------------------------------------------------------------------------------------------

推荐的好题不一定是难题，但往往带有那么一点代表性。凡是由别人推荐的题目，偶会加上推荐人ID和blog地址。偶自己推荐的题目，偶会尽量推荐一份简洁的代码。当天推荐的题会以红色标记。

Single Round MatchSRM 522 DIV1   1050pt ( 很不错的dp题，先需要思考来分析各种情况 ) 推荐代码: practice room writer
SRM 521 DIV1    500pt ( 枚举+小偏移，考思路 ) 推荐代码: ACRush,crazyb0y
SRM 521 DIV1   1000pt ( dp+矩阵相乘,主要是考状态表示和转移矩阵的建立 ) 推荐代码: 官方题解
SRM 520 DIV1    500pt ( dp+处理累和方法的状态表示技巧 ) 推荐代码: 官方题解
SRM 520 DIV1   1000pt ( 很不错的dp,考思维 ) 推荐代码: practice room writer
SRM 519 DIV1    600pt ( dp，如果不用自动机的话，状态表示需要想一下 ) 推荐代码: practice room crazyb0y
SRM 519 DIV1    900pt ( 枚举+dp+常数优化 ) 推荐代码: practice room crazyb0y
SRM 518 DIV1   1000pt ( 分治处理，需要推出一些结论 ) 推荐代码: practice room Petr,Sevenkplus;官方题解
SRM 517 DIV1    600pt ( 看出可以从任意一个位置打断的性质就只是一道普通dp题了 ) 推荐代码: Petr,nika
SRM 517 DIV1    900pt ( 能够通过对题目特点的分析看出构图的方式是重点 ) 推荐代码: practice room writer
SRM 516 DIV1    500pt ( 很明显的贪心 ) 推荐代码: Petr
SRM 515 DIV1    550pt ( 条件挖掘+期望计算+压缩dp ) 推荐代码: Petr,UdH-WiNGeR
SRM 515 DIV1   1000pt ( 枚举+优先队列的一种应用 ) 推荐代码: rng_58
SRM 510 DIV1    500pt ( 枚举，需要推出一些结论 ) 推荐代码: practice room meret
SRM 508 DIV1    500pt ( 按位+状态压缩dp ) 推荐代码: Petr
SRM 508 DIV1   1000pt ( 枚举+几何基础 ) 推荐代码: practice room zbwmqlw
SRM 507 DIV1    500pt ( 枚举+贪心的计算 ) 推荐代码: practice room writer solutionA
SRM 507 DIV1    900pt ( dp+组合数学基础 ) 推荐代码: rng_58
SRM 506 DIV1   1000pt ( 贪心的思路+dp ) 推荐代码: practice room neal_wu,rng_58,Louty
SRM 505 DIV1    300pt ( 规律，连通分量 ) 推荐代码: practice room writer
SRM 505 DIV1   1000pt ( 提取特殊情况+搜索或dp ) 推荐代码: Petr,UdH-WiNGeR
SRM 504 DIV1   1000pt ( 主要是看出规律 ) 推荐代码: 官方题解，bmerry,Petr
SRM 503 DIV1    500pt ( 求期望题.贪心，枚举，概率计算 ) 推荐代码: rng_58
SRM 502 DIV1   1000pt ( 第一次看到这种引入子问题的方式 ) 推荐代码: 官方题解
SRM 501 DIV1   1000pt ( dp+hash思维+树状数组，算是一种dp优化吧 ) 推荐代码: Petr,practice room ACRush,wata
SRM 500 DIV1    500pt ( 很考实现技巧的一题，分形+几何的旋转和放缩 ) 推荐代码: Petr,不过旋转方式最好参考官方题解，Petr写法有所不同
SRM 500 DIV1   1000pt ( 枚举+数学基础 ) 推荐代码: Petr
SRM 499 DIV1   1000pt ( 图论基础，强连通分量缩点+最长路 ) 推荐代码: hpfdf
SRM 498 DIV1   1000pt ( dp基础+容斥原理 ) 推荐代码: rng_58
SRM 497 DIV1    550pt ( 字符串处理基础+裸树形dp，需要一定的字符串处理功底 ) 推荐代码: Petr,ACRush
SRM 497 DIV1   1000pt ( 算是一种典型的题型吧。区间处理，预处理技巧 ) 推荐代码: ACRush,Petr
SRM 496 DIV1    500pt ( 关键在于二分图是特殊的，其实是链 ) 推荐代码: practice room writer
SRM 496 DIV1    950pt ( 需要很强大的贪心或者很强大的YY ) 推荐代码: UdH-WiNGeR
SRM 495 DIV1    975pt ( 数学+dp，很考思维的一题 ) 推荐代码: practice room writer
SRM 494 DIV1    500pt ( 陷阱题，数学基础 ) 推荐代码: wata
SRM 494 DIV1   1000pt ( 按特点构造矩阵+高斯消元 ) 推荐代码: Petr,practice room rng_58
SRM 493 DIV1   1000pt ( dp+实现技巧，如果情况统一得好，代码可以很短 ) 推荐代码: practice room rng_58
SRM 492 DIV1    550pt ( dp+基本的实现技巧 ) 推荐代码: rng_58
SRM 492 DIV1   1000pt ( 基于贪心思想的离散化+dijstra+代码实现技巧 ) 推荐代码: lyrically
SRM 491 DIV1    600pt ( 很不错的dp，关键是要能想到枚举子集 ) 推荐代码: wata
SRM 491 DIV1    900pt ( 可以分数规划+网络流，不过要注意精度；另外也可以贪心 ) 推荐代码: Rizvanov_de_xXx,论坛 RalphFurmaniak
SRM 490 DIV1    550pt ( 非常考英语阅读和代码实现能力的一题 ) 推荐代码: wata,官方题解
SRM 490 DIV1   1000pt ( BFS界限需要YY，矩阵or循环节，有些细节 ) 推荐代码: jialin,官方题解,practice room wata
SRM 489 DIV1    500pt ( 非常忽悠的一题 ) 推荐代码: 就几行，随便谁的代码吧
SRM 489 DIV1   1000pt ( 很不错的dp，貌似TC支持开的数组大小又大了 ) 推荐代码: practice room writer2
SRM 488 DIV1    250pt ( 逆推dp+求期望,一类基础的dp题型 ) 推荐代码: 官方题解
SRM 488 DIV1    500pt ( 现场非常惨烈，实际上n^5的暴力足够过 ) 推荐代码: 官方题解
SRM 488 DIV1   1000pt ( 相当于9个未知量，5个等式，枚举+一顿推，一顿限界 ) 推荐代码: 官方题解
SRM 487 DIV1    550pt ( 很忽悠的一题 ) 推荐代码: practice room writer,hhanger 及官方题解
SRM 487 DIV1    950pt ( 很不错的dp ) 推荐代码: practice room writer
SRM 486 DIV1   1000pt ( 没什么好说的，赞下wata的java凸包) 推荐代码: wata,practice room rem
SRM 485 DIV1    500pt ( 证明比较难想到，有了结论后dp+暴力搜即可) 推荐代码: wata
SRM 484 DIV1    550pt ( 很好的dp，状态设计得好会很短，常规思路的dp也可以过 ) 推荐代码: Petr,cgy4ever
SRM 484 DIV1    950pt ( 二分+贪心，易错，思路比较常规 ) 推荐代码: tomek
SRM 483 DIV1    500pt ( 很暴力的位压缩dp ) 推荐代码: wywcgs,practice room wata
SRM 483 DIV1    900pt ( 陷阱题，枚举+模拟，枚举的界限是关键 ) 推荐代码: wata
SRM 482 DIV1    500pt ( 思路清晰+基本代码实现技巧 ) 推荐代码: hhbhhb,tourist,wata
SRM 482 DIV1   1000pt ( 难题，思维转换，搜索基础 ) 推荐代码: practice room rng_58
SRM 481 DIV1    500pt ( 贪心，有关全排列期望计算 ) 推荐代码: rem,rng_58
SRM 481 DIV1    900pt ( dp基础 ) 推荐代码: wata
SRM 480 DIV1    450pt ( 需要一点思路，另外别中烟雾弹 ) 推荐代码: Petr
SRM 479 DIV1    250pt ( 简单的处理技巧 ) 推荐代码: wata
SRM 479 DIV1   1000pt ( 基本的状态压缩DP+清晰的思路+犀利的代码处理技巧，现场无人AC ) 推荐代码: practice room presley
SRM 478 DIV1    250pt   ( 需要看出4*x+3和8*x+7的规律 ) 推荐代码: UdH-WiNGeR
SRM 478 DIV1   1000pt   ( 非常不错的DP，需要思路很清晰 ) 推荐代码: UdH-WiNGeR
SRM 477 DIV1   1000pt   ( 不错的树形DP )推荐代码：wata
SRM 475 DIV1    600pt   ( 不错的数论题 ) 推荐代码：官方题解
SRM 475 DIV1    900pt （不错的dp）推荐代码：practice room writer
SRM 475 DIV2   1000pt （需要不错的构图思想）推荐代码：practice room writer
SRM 474 DIV1   1000pt （典型的树形DP，左孩子，右兄弟）推荐代码：rem
SRM 462 DIV1    250pt ( trick题，AC率奇低）推荐人：baihacker
SRM 449 DIV2    250pt   ( 需要一点思维）推荐人：daizhenyang
SRM 409 DIV1    900pt （枚举+概率）推荐代码：官方题解
SRM 403 DIV1    500pt （dp，矩阵乘法）推荐代码：UdH-WiNGeR
SRM 401 DIV1    950pt ( 关键idea+暴力扫描）推荐代码：practice room windy7926778
SRM 358 DIV1    500pt   ( 暴力可以过，但是需要思考为什么暴力可以过) 推荐代码：practice room wata
SRM 358 DIV1   1000pt   ( 基础的网络流题型 ) 推荐代码：practice room wata,daizhy
SRM 147 DIV1   1000pt (DP，易错，因为数据类型的问题）推荐代码：tjq，practice room meret
SRM 145 DIV1    600pt ( 纯模拟，考察基本功，代码50行左右，但当时最快的SnapDragon大神居然只做到508.66分 ) 推荐代码：practice room meret
SRM 144 DIV1   1100pt （图论，需要很好的代码处理技巧和建图思维）推荐代码：practice room RRi

Topcoder Tournament

TCO'10 Championship Round 500pt ( 皮克定理+数论基础 ) 推荐代码：官方题解
TCO'10 Championship Round 1000pt ( 动态规划基础+重复排列计算+预处理技巧 ) 推荐代码：practice room writer
TCO'10 Wildcard Round    250pt ( dp基础 ) 推荐代码：practice room bmerry，官方题解
TCO'10 Wildcard Round    500pt ( 一点思维+dp基础 ) 推荐代码：practice room bmerry
TCO'10 Wildcard Round   1000pt ( 分情况+矩阵+快速乘幂+lucas定理+费马小定理+组合计算 ) 推荐代码：官方题解
TCO'10 Semifinal 2       950pt ( 对半分+简单扫描技巧+离散化+树状数组 ) 推荐代码：practice room GeRich
TCO'10 Semifinal 1       250pt ( 考基本功的一题 ) 推荐代码：官方题解
TCO'10 Semifinal 1       500pt ( 一个很不错的计算技巧，二分+dp都很常规 ) 推荐代码：官方题解
TCO'10 Semifinal 1       950pt ( 枚举+dp,注意到双向都dp一下，最后综合 ) 推荐代码：官方题解
TCO'10 Online Round 5    500pt ( dp+贪心，状态的选取需要贪心的想 ) 推荐代码：bmerry，Petr。
TCO'10 Online Round 5   1000pt ( 现场无人AC，很亮的一题。暴力递归+剪枝+并查集+容斥中的排斥 ) 推荐代码：practice room StevieT
TCO'10 Online Round 4    500pt ( 枚举+贪心，易错型题，需要不错的思维能力 ) 推荐代码：官方题解
TCO'10 Online Round 4   1000pt ( 几何基础-----从角度分析，一种典型的思维+仔细的分析 ) 推荐代码：官方题解
TCO'10 Online Round 3    250pt ( 数论，需要一点思维 ) 推荐代码：官方题解
TCO'10 Online Round 3   1000pt ( 数论+组合，很考基础的一题 )　推荐代码：practice room neal_wu
TCO'10 Online Round 1    500pt ( 枚举，逆向思考 ) 推荐代码：practice room darnley 推荐阅读：官方题解
TCO'09 Elimination Round 5 1000pt (枚举+二分图，二分图隐藏得比较深) 推荐代码：ACRush

Read full article from [转]Topcoder好题推荐 by 白衣少年 - 天亮说晚安 - 博客频道 - CSDN.NET

Interview----求 1+2+...+n, 不能用乘除法、for、while if、else、switch、case 等关键字以及条件判断语句 (A?B:C) - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

题目描述：

求 1+2+...+n,
要求不能使用乘除法、for、while、if、else、switch、case 等关键字以及条件判断语句 (A?B:C)。

分析：

首先想到的是写递归函数，但是遇到一个问题，递归函数总需要一个出口，不然会无穷递归下去。

出口一半是 if() return. 题目又要求不能使用 if 语句。

什么语句有类似与 if 的选择功能呢？？

Read full article from Interview----求 1+2+...+n, 不能用乘除法、for、while if、else、switch、case 等关键字以及条件判断语句 (A?B:C) - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

TopCoder----卖柠檬 - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

1. 题目描述

Problem Statement

You are playing a game called Slime Tycoon.You will be selling Slimonades in this game, and your goal is to sell as many as you can.
The game will consist of N game days, numbered 0 through N-1 in order.You are given two vector <int>s morning and customers with N elements each, and an int stale_limit.These represent constraints on how many Slimonades you can produce and sell, as explained below.

In each game day, three things happen, in the following order:

Early in the morning of day i: All Slimonades that were produced stale_limit days ago (i.e., on day i-stale_limit) go stale. You cannot sell stale Slimonades, you must throw them away immediately.
During day i: You can produce at most morning[i] new Slimonades. (Formally, you choose an integer X between 0 and morning[i], inclusive, and produce X Slimonades.)
In the evening of day i: You can sell at most customers[i] Slimonades. (That is, if you have at mostcustomers[i] Slimonades, you sell all of them. Otherwise, you sell exactly customers[i] Slimonades. In that case, you get to choose which Slimonades you sell and which ones you keep for later days.)

What is the maximum total number of Slimonades that you can sell during these N days?

Definition

Class:	SlimeXSlimonadeTycoon
Method:	sell
Parameters:	vector <int>, vector <int>, int
Returns:	int
Method signature:	int sell(vector <int> morning, vector <int> customers, int stale_limit)
(be sure your method is public)

Limits

Time limit (s):	2.000
Memory limit (MB):	256

Constraints

morning will contain between 2 and 50 elements, inclusive.

Each element of morning will be between 0 and 10000, inclusive.

customers will contain the same number of elements as morning.

Each element of customers will be between 0 and 10000, inclusive.

stale_limit will be between 1 and N, inclusive.

Examples

{5, 1, 1}

{1, 2, 3}

Returns: 5

Here's one optimal solution.

Day 0: We produce 4 Slimonades, then sell 1 of them.
Day 1: We produce 1 Slimonade (so now we have 4). In the evening, we sell two of the Slimonades that were made yesterday.
Day 2: We still have one Slimonade that was made on day 0. It goes stale and we throw it away. We produce one more Slimonade. In the evening, we sell 2 Slimonades (the one made yesterday and the one made today).

Read full article from TopCoder----卖柠檬 - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

算法----中位数算法的妙用(更新中) - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

中位数算法O(N)有许多妙用，能够在一些场合下替代排序O(NlgN)

1. 中位数算法

求N个数组中的中位数即求第n/2大的数

算法导论中给出了两种求第k大的数的算法

算法1：随机算法平均复杂度O(n)

思路：利用quicksort的随机版本的partition, 将数组分成2部分：

if 左边部分数目<k, 则在右边递归搜索

else if 左边的数> k，则在左边递归搜索

else return a[partition];

算法2：确定性算法最坏复杂度O(n)

2. 三个例子

例题1：带权中位数

n个数x[1], x[2],..., x[n], 各自带有一个权重， w[1], w[2], ..., w[n], w的总和是1

求x[k]满足所有满足x[i] < x[k]的元素的权重之和< 1/2，所有满足x[i] > x[k]的元素的权重之和 >=1/2;

算法1：先排序O(NlgN)，从前往后遍历数组，找到第一个x[k], 使得前k个元素的权重之和>=1/2, return x[k]

算法2：分治: 用中位数算法，将问题的规模减半

思路：其实这个题并不需要排序，我们仅仅需要找到 n个数中较小的K(未知)个数的集合，使得它的和<1/2, 其他元素的和>=1/2, 具体这两个集合中的数并不需要排序。考虑用中位数算法来找这个集合。

伪代码： WeightedMid(a, i, j, w)

mid = Select(a, i, j) //中位数算法

left_sum = w[i]+w[i+1]+...+w[mid-1]; //左半部分数组的权重和

right_sum = w[mid+1]+w[mid+1]+...w[j];

if left_sum >=w, return WeightedMid(a, i, mid-1, w);

elseif right_sum >w, return WeightedMid(a, mid, j, w-left_sum);

else return x[mid];

T(n) = T(n/2) + O(n)

例题2：部分背包问题：

一个窃贼去一家商店偷窃，有n件商品：第i件物品值vi元，重wi榜（vi, wi都是整数），他的背包最多只能装下W榜物品，

每件商品他可以选择一部分带走，而不像0-1背包问题。问他最多能带走多贵的物品？

分析：由于部分背包问题允许仅拿走物品的一部分，物件更像是金粉，可证明其具有贪心的性质。

算法1： 贪心

按照每榜的价值进行排序，然后由价值的大小依次往包里装，直到重量为W。

算法复杂度是 O(nlgn).

能不能将其复杂度降低到线性呢？

注意到，无论是动态规划还是贪心，其实都具有问题可分（decomposed)的性质, 也就是可以考虑用分治（divide-and-conquer)。

要构造O(n)的算法，首先想到 T(n) = T(n/2) + O(n)，

--------------- 在O(n)的时间内把问题的规模降为一半，那么就得到了一个O(N)的算法。

分析：

贪心算法时间复杂度主要是排序，可以不排序吗？

可以。排序只是为了找出那些单价高的物品集合，所以我们并不需要把所有的单价进行排序。

我们只需要找到背包所能装得下的那部分单价较高的物品即可。这类似于在数组中找前k大的k个数（复杂度是O(N)）.

因此使用排序我们其实做了多余的比较。

目标：一分为二，而且要找的是前k大的k个数（k未知），

Bingo！先找出中位数!

算法2：

n个物品的单价数组： A[1:n]

找出其中位数，将数组分成3个部分： A{单价高于中位数} B{单价等于中位数} C{单价小于中位数}

注意到 {A}, {A+B}， {C}的规模<=n/2

下面分三种情况：

1. 若集合A中的物品总质量 >= W，递归在A中解部分背包问题

2. 若集合A中的物品总质量 < W, 且集合{A+B}中的物品总质量 >=W, 将A中物品全部装入包中，剩余的从B中随便取即可

3. 若集合{A+B}中的物品总质量 < W, 将A和B中的物品全部放入背包中，剩余的质量递归地在集合C中求解

复杂度分析：

求中位数复杂度是 O（N）, 上述三种情况中除了子问题外，也顶多花O（N）时间，

T(n) <= T(n/2) + O(n)

所以 T(n) = O（n)

例3：

N个数中有一个数出现的次数大于1/2

算法1：先排序，再扫描一次数组，记录出现的次数 O(nlgn)

算法2: 这一问题其实也不需要排序。中位数即为所求。O(n)

Read full article from 算法----中位数算法的妙用(更新中) - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

数学----有趣的扑克牌《一》 - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

一副扑克牌，除去大小王后共52张牌，随机从中抽八张牌，问八张牌的和最有可能是多少？

分析：

这52张牌，其实就是数字 1 2 3 。。。13，每个数字出现4次。随机抽出8个数，问组成的和最有可能是多少？

聪明的你可能想到了另一个很类似的问题，2 sum: 问一个数组中是否存在两个数的和等于某个给定的值。

当然，这里就类似于 8 sum。但是，题目却问的是，最有可能的结果是多少？

怎么分析呢？

最简单，但最有效的方法就是举个例子，就能理清思路了。

和最小的话就是 1 + 1 + 1 + 1 + 2 + 2 + 2 +2 = 12, 可以想象这个和12来说，出现的概率非常之低。

同样，对于和 12*4 + 13*4= 100 来说，出现的概率同样非常之低。

那么[12, 100] 中间的数呢？可以想象，这些数有更多的数的组合，使得其和等于这个值，因此概率更大。

大胆地猜想，（12 + 100）/2 = 56，概率最大，越靠近这个和，出现的概率越大。

验证：

数学讲究严密性。刚刚的猜想是建立的观测的基础之上的。但是想必还是不能服众。

1. 另一种简单的分析思路：

大家可以看看 1 2 ... 12 13 , 这13个数其实是非常对称的。

为什么这么说呢，【1+13】= 【2+12】 = 【3+11】= 。。。。= 【6 + 8】

『高斯小的时候就发现了这个规律。。』

上述的和都是 14, 也就是说，平均下来一个数就是7，因此7*8 = 56 的可能性最大。

当然，这样分析，不够严谨，但有的时候，观察 + 猜想 = 成功

2. 咱们是学计算机呢，直接跑个程序验证不久 okay了。

最简单暴力的，就是枚举所有的情况，统计所有的和出现的次数。

当然，可能有人会说了，那不就是八重循环，吓死人啊....

可以采用 DFS，就能避免写这么多个for 循环，代码如下：

Read full article from 数学----有趣的扑克牌《一》 - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

算法----bonus dumplings - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

题目描述

过年了，妈妈做了100只饺子，其中有10只饺子里面有1块的硬币。
小明依次吃这100只饺子，如果小明连续吃到k个硬币，那么小明得到k-1个硬币。

e.g. 110111表示6只饺子，1表示有硬币，0表示没有。11表示连续吃到2个饺子，那么小明得1个硬币；111连续迟到3个，小明得2个硬币；故，小明共得到3个硬币。

问小明得到的硬币的期望值是多少？

分析

期望定义： E(X)=∑iXiP(Xi)

在本题中，随机事件X即为小明最终得到的硬币数目，x∈[0,9]

计算P(Xi)=cases(x=i)allcases
计算期望

那么原问题就简化为小明得到硬币k,所有可能的cases的数目。

采用动态规划，子问题定义如下

f[i][j][k]――前i个饺子，含j个有硬币的饺子，得分是k，且第i个饺子不含硬币，所有可能的情况的总数。
g[i][j][k]――前i个饺子，含j个有硬币的饺子，得分是k，且第i个饺子含硬币，所有可能的情况的总数。

那么递推公式如下,

f[i][j][k]―-第i个饺子不包含硬币，所以不用第i个饺子
- f[i][j][k] = f[i-1][j][k] + g[i-1][j][k]
g[i][j][k]―-第i个饺子包含硬币，那么这个硬币能够得到，取决于第i-1个饺子是否包含硬币
- g[i][j][k] = f[i-1][j-1][k] + g[i-1][j-1][k-1]

Read full article from 算法----bonus dumplings - L.J.SHOU的专栏 - 博客频道 - CSDN.NET

有趣的题目系列一：实现具有最大值、最小值、中间值的栈和队列 - 1ouis的专栏 - 博客频道 - CSDN.NET

番外知识：Java反射详解

番外二：

<?>是1.5的新特性，泛型 如果是?表示可以放Object类型以及他的子类

如果是String 表示只能接收String以及他的子类。 Class<?> c表示这个Class可以放任意的类,?表示object(所有类都隐性从Object继承的) Class<String> c 只能接收String和他的子类（本文中的<E>也是这种情况） Class c和Class<?>c性质是一样的

===========================================

题目来源：

1）http://blog.csdn.net/bigheadzzy/article/details/8002253

2）http://blog.csdn.net/yangzhongblog/article/details/12391959

文章中的大部分题目描述、代码均参考自上面二处，加以自己的一些理解。

-------------------------------------------------------------------切割-------------------------------------------------------------------------

Works Applications的笔试题：

要求实现下面两个接口，实现要求：运行速度快，每个操作时间复杂度不能相差太大。

一，实现Immutable的FIFO队列。也就是说要求入队和出队不会改变原来的队列。

Read full article from 有趣的题目系列一：实现具有最大值、最小值、中间值的栈和队列 - 1ouis的专栏 - 博客频道 - CSDN.NET

WAP面试经历 | 傲娇的码农

株式会社ワ�`クスアプリケ�`ションズ（Works Applications）于1996年在日本东京成立，2012年美国《财富》杂志评选――日本最佳雇主"2012 JAPAN BEST COMPANIES TO WORK FOR"排行榜中位列第二。
Works Applications在HR软件领域（面向日本大型企业）的市场占有率为59.4%，位列第一。公司成立5年就在日本JASDAQ（日本创业板）市场上市，连续12年保持20%以上的业务增长率。现有员工2800余人。
2012年2月，Works Applications上海研发中心（上海万革始应用软件有限公司）正式开始运营。

面试经历

十月中旬WAP在我们学校开宣讲会，然后便在现场报名了，而且也在网上进行了报名。过了几天，收到了WAP的网络编程笔试题。题目不是特别难，只要代码通过测试，便能进入一面。

在十一月初，我收到了WAP的一面通知，负责招聘的人告诉我面试时间大概是15分钟左右，需要熟悉自己之前写的笔试题目的代码，因为面试官可能会针对那个笔试题，进行提问。并且还需要准备两份简历（中英文各一份）。

十一月八号在北京参加面试。到达现场我们才知道，首先得进行测试，一套卷子三十个题目，全是选择题。卷子不难，全是简单的高中数学题。但是得在一个小时之内做完。

做完测试题之后才开始真正的一对一面试，面试官是日本人，英语说得很吃力，但是很有礼貌。我的面试官是一位女性，估计30多岁的样子。面试现场有一张桌子，两个人面对面坐着，有两台电脑，参加面试的人在机器上敲代码，面试官可以实时监控。电脑应该是开了一个虚拟机，流畅度不是很高，编译器用的是Codeblocks。

首先开场需要用英文进行自我介绍，由于之前没有准备好，所以一开场就开始悲剧。用蹩脚的英文进行自我介绍之后，面试官给了一份纸质的题目，上面只有一个题目，要求是在尽可能少的时间内完成这个题目。我的题目是最长公共子序列，把该序列打印出来。由于比较紧张，也没怎么想，就直接开始暴力，其中还出现一些小问题，例如边界情况没有考虑好，花了大概二十分钟才把代码敲完，加上自我介绍和其他的时间，面试已经过了大概三十五分钟。

在我敲代码的过程中，面试官时不时的会在记录本上面记录，没有说话，只是偶尔点点头。敲完第一个题目之后，她给出了第二份题目，第二份题目是一个综合题，里面包括三个问题，并且针对每个问题都给出了一个样例。在看题目的过程中也出现了一些理解上的偏差，有个题目我问了她三遍才听懂她的要求（日本人的英语发音确实不敢恭维，而且自己的口语也不好）。

第一个问题是输出最长递增子序列，并且把这个子序列打印出来。第二个是输出最长的连续相同的子序列，并且把子序列打印出来。第三个是不考虑英文字符的大小写，输出最长的连续相同的子序列，并且把子序列打印出来。

在敲这个代码的时候我犯了一个很大的错误，那就是我没有思考，就直接开敲，最重要的是我把三个问题敲成了三份代码，这样十分的浪费时间。而且没有用到面向对象的思维，把三个问题敲成一份代码，使这份代码可以解决三个问题，这样才是正解。所以最后我第三个问题还没敲完，就已经time over了。

在进行代码测试之后，面试官就开始问我有没有什么需要问她的，我当时大脑一片空白，完全不知道应该问什么。所以就随便问了一个关于他们公司的工作氛围的问题，还有工作团队之间的工作分配问题。然后她想了下就开始回答我，我当时完全听不进去她在讲什么，只是礼节性的点点头。最后她回答完问题之后就示意我可以结束了。

面试结束，我就知道我应该是跪了。从李大神那得之二面的题目是一个栈实现的括号匹配问题，二面结束后就直接是HR面了。

Read full article from WAP面试经历 | 傲娇的码农

Works Applications是一个怎样的公司？ - 信息技术（IT） - 知乎

它家的招聘介绍里写是日本日本最佳雇主，在HR软件领域（面向日本大型企业）的市场占有率位列第一。给应届生开出的在上海的薪酬也比较诱人。进一步的搜索看到IDC今年6月的数据是在日本ERP市场的某些分项上它家也只是SAP\IBM\ORACLE之后的第四，而且11年在私募基金的支持下退市了，而且和workssol这个集团好像也有相当关系。

Read full article from Works Applications是一个怎样的公司？ - 信息技术（IT） - 知乎

jirutka/rsql-parser

RSQL is a query language for parametrized filtering of entries in RESTful APIs. It's based on FIQL (Feed Item Query Language) – an URI-friendly syntax for expressing filters across the entries in an Atom Feed. FIQL is great for use in URI; there are no unsafe characters, so URL encoding is not required. On the other side, FIQL's syntax is not very intuitive and URL encoding isn't always that big deal, so RSQL also provides a friendlier syntax for logical operators and some of the comparison operators.

For example, you can query your resource like this: /movies?query=name=="Kill Bill";year=gt=2003 or /movies?query=director.lastName==Nolan and year>=2000. See examples below.

This is a complete and thoroughly tested parser for RSQL written in JavaCC and Java. Since RSQL is a superset of the FIQL, it can be used for parsing FIQL as well.

RSQL-parser can be used with RSQL-hibernate, library to translate RSQL expression to Hibernate's Criteria query (it's written for 1.x version of the parser though), or RSQL-MongoDB.

Read full article from jirutka/rsql-parser

Immutable ArrayList in Java | Baeldung

This quick tutorial will show how to make an ArrayList immutable with the core JDK, with Guava and finally with Apache Commons Collections 4.

Read full article from Immutable ArrayList in Java | Baeldung

Java Arrays.asList() returns immutable list | Ledld

Surprisingly, the method Arrays.asList(T…a) returns an ArraysList that doesn't implement the add or remove method (as it says in the specs is fixed size list), so trying to do something like this:

Read full article from Java Arrays.asList() returns immutable list | Ledld

history - Why doesn't Java 8 include immutable collections? - Programmers Stack Exchange

Because immutable collections absolutely require sharing to be usable. Otherwise, every single operation drops a whole other list into the heap somewhere. Languages that are entirely immutable, like Haskell, generate astonishing amounts of garbage without aggressive optimizations and sharing. Having collection that's only usable with <50 elements is not worth putting in the standard library.

Further more, immutable collections often have fundamentally different implementations than their mutable counterparts. Consider for example ArrayList, an efficient immutable ArrayList wouldn't be an array at all! It should be implemented with a balanced tree with a large branching factor, Clojure uses 32 IIRC. Making mutable collections be "immutable" by just adding a functional update is a performance bug just as much as a memory leak is.

Furthermore, sharing isn't viable in Java. Java provides too many unrestricted hooks to mutability and reference equality to make sharing "just an optimization". It'd probably irk you a bit if you could modify an element in a list, and realize you just modified an element in the other 20 versions of that list you had.

This also rules out huge classes of very vital optimizations for efficient immutability, sharing, stream fusion, you name it, mutability breaks it. (That'd make a good slogan for FP evangelists)

Read full article from history - Why doesn't Java 8 include immutable collections? - Programmers Stack Exchange