madongfly的天空

我的2010年终总结

madongfly — Fri, 31 Dec 2010 18:49:50 +0800

时间过得好快，一年就这样过去了，2010是我的本命年，也是我来到这个世界上的24年中发生的事情最多也最大的一年，在此总结一下，以纪念这不同寻常的一年。

成长

人都是在不断成长的，不过这一年中经历的事情，对我的成长所造成的影响可能更大于以往的数年。

年初的时候，领着飞一起回家了，却没有想到家里发生了那么大的事情，也幸好有飞陪在我的身边，才让我这个“伪坚强”的男人带着坚强的面具度过了那段最艰难的日子。

家里的事改变了我的很多看法，夸张点说，甚至重塑了我的价值观。当然这个改变是逐渐渗透的，由最开始一些很不成熟甚至带有一点冲动的想法开始，逐渐的沉淀，通过慢慢的思考领悟到了很多的道理。现在回头来看，这段经历虽然痛苦，却也是很难得的人生财富。

在这件事情上，我从弟弟身上学到了很多，虽然小我两岁半，但在整个事件中，弟弟的表现却比我更加成熟，弟弟的坚强与成熟给了我很大的鼓舞，但看着他以这样的年龄，承担那么多的责任，我在心疼的同时也为自己这个不太称职的哥哥感到惭愧。今天回过头来，我很想对他说，小昆，我为有你这样的弟弟感到骄傲！

应该说，2010年的上半年，对我来说是灰色的，幸亏有飞，有月雷，庆哥你们这帮朋友，真的很感谢你们！

开学后喜欢上了五月天，当时整天听着《疯狂世界》，“我好想好想飞，逃离这个，疯狂的世界……”，有一天突然听到了《我心中尚未崩坏的地方》，歌词给了我巨大的触动，不管现实如何，“至少在我的心中，还有个尚未崩坏的地方”。于是买了两张五月天的演唱会门票，和同样喜欢五月天的弟弟一起去了现场，算是送给弟弟的21岁生日礼物，那天晚上同弟弟手拉手一起大声跟着唱的场景，必将永生难忘。

10年让我学会了很多，却也让我一度对实验室的事情不太上心，很多工作都是应付了事，仔细想来，也觉得有些让老板失望了。

去年年底答应过老板，要做一个所谓的“数据挖掘云服务”的平台，当时还很认真的规划，设计。但等到开学的时候，因为心情的原因，变成了彻底的应付，花了一个多月的时间，写了一个可以演示的小型系统，现在想来，真的很惭愧，如果明年有时间的话，希望能够再改进一下。

离别

毕业的季节总是很伤感，实验室的师兄师姐们走了很多，叶飞师兄，小马姐，赵哥，坤荣师兄等等。

我最好的朋友可以分为两类，一类是通过慢慢的接触，互相了解之后，开始变得很铁，像月雷，庆哥，杨茂，汪庆等等就是这一类，这类朋友也是最多的。而另一类是那种我刚跟他说了几句话就有种极强烈的感觉要和他做朋友，后来也就真的成了很好的朋友，这类人很少，小学时代的马松，初中时代的刘华，高中毕业后认识的张鹏都属于这一类。而研究生期间，竟然有两位师兄让我有这种感觉，叶飞师兄和坤荣师兄，只可惜和他们的相处都太短暂了。

和叶飞师兄的相处是最短暂的，刚刚才和他开始熟络起来，他就要去美国了。坤荣师兄又太忙，而出了实验室我们生活中的交集又太少，没能和这两位师兄深交是我研究生期间最大的遗憾。

小马姐和赵哥的离去也让实验室彻底失去了以往的活力和氛围，而赵哥、坤荣师兄、老李师兄的毕业，也让我失去了最好的球友，从此我更多的是一个人去篮球场。说起篮球，一件值得记录的事情就是在今年所里的篮球赛中，我终于成为了实验室的主力。:)

10年最伤感的离别要算杨茂和张鹏这两人带来的，一个去昆明，一个去重庆，一个是考了研究生才终于得以在北京相聚的好友，一个是几次告诉我说要留在北京最后却又选择离开的“舍杠”，两个“贱人”，和你们告别的那几天搞的我都有点抑郁了。

找工作

找工作是我和弟弟在10年最重要的事，对应于上半年的艰难，我们找工作的过程都还是比较顺利的，最后也都去了各自最想去的地方，也算是10年最大的喜事。关于找工作的事之前已经写过太多了，这里就不罗嗦了。

最后总结一下10年读过的书和看过的电影，因为年初就开始在豆瓣上记录，所以有现成的数据，顺便总结一下。

读过的书

10年总共读完了31部书，其中小说12部，历时杂文类书籍6部，认知心理学类书籍5部，人物传记2部，技术类书籍6部。

完整的豆列在这儿。其中最震撼的小说是《兄弟》和《三体III》，也因为《兄弟》，让我喜欢上了余华，尤其喜欢他那句“再荒诞的小说也他妈的没有现实荒诞”。看完《兄弟》之后我曾写了一篇文章在这儿。另外，还有一篇《观止——微软创建NT及未来的夺命狂奔》的书评在这儿。

而让我思考最多的是6部历史杂文类书籍，给我映象最深刻的是《潜规则》、《万历十五年》和《民主的细节》，尤其是吴思的《潜规则》，我也曾经写过一篇书评在这儿。顺便提一下，10年看过最无聊的书就是于丹的《庄子心得》了……

认知心理学类的几部书也让我学到了很多，其中，《天才在左，疯子在右》曾带给我很大的震撼。

人物传记看了唐骏和乔布斯的传记。

技术类书籍都是为了应用现看的，其中《CSAPP》（Computer Systems: A Programmer’s Perspective）给我的帮助最大，顺利通过各种笔试都是靠它。看完这本书也曾经写过一个总结在这儿。

看过的电影

除去以前看过的，10年新看了49部电影（豆列在这儿），其实有很多是多年前的经典片，但以前还没看过的，主要是由于下半年买了Ipod Touch，所以经常往上面拷电影。

给我震撼最深的是以前看过的《教父》系列，以前可以说完全没看懂，这一次，从中领悟到了太多的东西，曾让我思考了一夜，一度很想把从这三部电影中感悟到的东西写下来，但一直没有动笔，直到有一天突然意识到我的这些领悟带有太强烈的主观色彩，很明显和10年的经历有关，而今年经历过的这些事，必然会成为以后人生道路中一遍遍思考的东西，现在的思考也必然还不够成熟。

结束语：2010年如此不同寻常的一年马上就要逝去了，过去的永远都是过去，放下过往的包袱，轻装上阵，迎接新的一年，新的未来……

为求职事致谢

madongfly — Wed, 01 Dec 2010 11:55:43 +0800

历时近三个月，经历了9家公司的5轮笔试，16轮30次面试之后，终于在今天提交了三方协议，标志着找工作的正式结束。

在这一期间，有太多的人帮助过我，特此写下这篇日志，算是迟来的感恩节日志吧。

首先，感谢我的家人。10年，是咱们最艰难的一年，父亲母亲，您们受苦了！如今我和弟弟都找到了满意的工作，您们放心吧！感谢您们对我的培育！

感谢飞，在我找工作这段时间里，陪你的时间很少很少，谢谢你一如既往的支持我！

感谢好友月雷、谭庆，你们陪我一起研究笔试面试题，让我受益匪浅！

感谢找工作途中的好伙伴们，月雷、小亮、周郴、李想、王洋、婷婷、王强、袁辰雨、黄武、刘州杰以及所有群里的703班兄弟们……我们一起分享信息，分享经验，谢谢你们！

感谢Roba、Han Chao和我一起分享信息，谢谢！

感谢罗平师兄，在您指导下研究的Topic Modelling方面的内容让我在找工作的时候加分不少，同时谢谢您为我推荐创新工场。

感谢创新工场的Dr. Xiong，谢谢您的器重！感谢吴卓浩总监，谢谢您和我分享您的工作经历！

感谢淘宝的铁象，谢谢您如此看重我，并等了我那么长时间，谢谢您！

感谢百度的戴文渊学长，求职百度的过程有些波折，您给了我太多的帮助，非常感谢您！

感谢盛大创新院的刘志斌先生和邱先生，盛大创新院是我面过的最有诚意的公司之一，谢谢您们如此看得起我！

感谢Google 的一面面试官和加面面试官，我暂时还不知道您们的名字，谢谢您们对我的鼓励！

感谢Google 的Hr Angela，您是我碰到的最Nice的Hr，谢谢您一直和我保持联系，度过了这段难熬的等待……

感谢百度的辜斯缪、孙立波童鞋，谢谢你们为我提供了很多信息！

感谢何子文童鞋和何志坚大哥，谢谢你们为我提供的信息！

感谢于亚光老师，是您坚定了我等待Google的决心！

感谢周世佳老师，谢谢您给予我那么多的帮助！

感谢卢山师兄、王勇睿师兄、林乐宇师兄、翟艺涛师兄，谢谢您们帮我内推！

感谢所有帮助过我的人，谢谢你们，祝你们平安，快乐！

有趣的逻辑推理题–2

madongfly — Tue, 23 Nov 2010 22:59:10 +0800

接有趣的逻辑思考题–1

答案同样设置成了白色，选中后可看。

12.一个桶装满10斤油，另外有一个能装3斤油的空桶和一个能装7斤油的空桶。试用这三个桶把10斤油平分为两份。

答案：按(10斤桶油量，3斤桶油量，7斤桶油量)的格式，初始值为(10,0,0)，按以下变换可得(7,3,0),(7,0,3),(4,3,3),(4,0,6),(1,3,6),(1,2,7),(8,2,0),(8,0,2),(5,3,2),(5,0,5)。

13.有大、中、小三个酒桶，分别能装19斤、13斤、7斤酒。现在大桶空着，另外两个桶都装满了酒。试问：用这三个桶倒几次可以把全部酒平分成两份？

答案：按(19斤桶油量，13斤桶油量，7斤桶油量)的格式，初始值为(0,13,7)，按以下变换可得(7,13,0),(19,1,0),(12,1,7),(12,8,0),(5,8,7),(5,13,2),(18,2,0),(11,2,7),(11,9,0),(4,9,7),(4,13,3),(17,0,3),(17,3,0),(10,3,7),(10,10,0)。

14.有10瓶药丸，每瓶有药丸1000粒。其中若干瓶内为超重药丸。普通药丸5g/每粒，超重药丸6g/每粒，每瓶药丸的数量相同。求：只用一架秤，只称一次，找出哪几瓶装有超重药丸。

答案：二进制原理，对瓶子编号1到10，分别拿出1,2,4,8,…,512颗药丸称重得w，令x = w – 1023*5; 看x的二进制表示，若某一位k为1则对应的k号瓶子是超重药丸。

15.有5瓶药丸，每瓶有药丸1000粒。其中每瓶的重量都不同，药丸分别为 5g/每粒，6g/每粒，7g/每粒，8g/每粒，9g/每粒。
每瓶药丸的数量相同。求：只用一架秤，只称一次，称出不同重量的药丸分别对应那瓶。

答案：五进制原理，5个瓶子编号为1到5，分别取出1，5，25，125，625颗药丸称重得w，令x = w – 5*(1+5+25+125+625)，则原来的5种药丸对应于：0g/每粒，1g/每粒，2g/每粒，3g/每粒，4g/每粒。所以将x写成五进制，必然是 01234五位数字的排列，设第k位(从低位往高位数)上数字为dk, 则第k个瓶子对应的就是(dk+5)g/每粒的药丸。举例，x = 21304(五进制)，则1到5号瓶子对应的药丸分别是9g,5g,8g,6g,7g。

16.1个重40g的天平砝码掉到地上摔成了4块，用这4块砝码可以称量1—40g的所有重量，请问：这4块砝码的重量分别是多少？

答案：1,3,9,27。三进制原理，在三进制表示下，所有的数都可以由这样的两个数相加或相减得到：这两个数的每一位都只为1或者0，并且如果把这两个数看成2进制的话，他们异或之后为全1。这正好对应了天平称重。

17.一天，A 君和 B 君一起在路上走着，遇见 B 君的三个熟人 X、Y、Z。
A 君问起 B 君：“他们三个人今年多大？”
B 君想了想说：“那我就考考你吧：他们三人的年龄之和为我们两人年龄之和，他
们三人年龄相乘等于2450。”
A 君算了算说：“我还是不知道！”。
B 君听后笑了笑说：“喔！那我再给你一个条件－－他们三人的年龄都比我们的朋
友 C 君要小。”
A 君听后说：“喔，那我知道了。”
最后问 C 君的年龄是多少？

答案：50。X,Y,Z有可能的组合为（2,25,49）（10,5,49）（10,35,7）（50,7,7）（14,7,25）（14,35,5）（98,5,5），他们的和分别为76, 64, 52, 64, 46, 54, 108。因为A君算了后还是不知道，说明A和B的年龄和为64，有两个可能（10,5,49）和（50,7,7），最后都比C小之后A君可以确定答案，说明C的年龄就是50。这个题的一个小技巧是枚举X,Y,Z的组合的时候，可以先把2450分解质因数得 2450 = 2*(5^2)*(7^2)，这样就比较好枚举了。

18.一个人花8块钱买了一只鸡，9块钱卖掉了，
然后他觉得不划算，花10块钱又买回来了，11快卖给另外一个人
问他赚了多少钱？
大家都来想想吧，最好说个理由。

答案：2块。我第一次碰到这个题的时候一不小心就陷入思维误区了，我当时想的是，第一次买卖挣了1块，再买回来亏了1块，再卖又挣1块，所以是1-1+1 = 1块。仔细想想就能明白是怎么回事了，貌似还有一些类似找钱找来找去少了几块的问题也是考这种思维误区的。

19.有四个朋友住在一个小镇里，他们的名字是：库克，米勒，史密斯，卡特。他们的职业是：一个是警察，一个是木匠，一个是农民，一个是医生。
一天，库克的儿子率断了退，库克带他去找医生，医生有个妹妹是史密斯的妻子。农民没有结过婚，他养着很多母鸡。米勒经常去农民那里买鸡蛋。警察每天都能见到史密斯，因为他们是邻居。
请分析，谁是警察，谁是木匠，谁是农民，谁是医生？

答案：简单的推理题。库克是警察，史密斯是木匠，卡特是农民，米勒是医生。

20.有这样一个故事：在太平洋中有A,B两个相邻的岛。A岛的居民都是诚实的人，B岛的居民都是骗子。当你问一个问题的时候，A岛的居民会说实话，B岛的居民会说假话。一天，一个旅游者登上了这两个岛中的某个岛。他分辨不轻这是A岛还是B岛，只是知道这个岛的人既有本岛的居民，又有另一岛的来客。他想问问路人：“这是A岛还是B岛？”却又无法判断被问者的答案是否正确。旅游者想了一会，终于想出了一个办法，他只需要问他所遇到的任何一个人一句话，就能从对方的回答中准确无误的判断这里是哪个岛。
请问，你能说出旅游者所提出的问题吗？

答案：你是本岛居民吗？

有趣的逻辑思考题–1

madongfly — Mon, 22 Nov 2010 15:59:07 +0800

在找工作的过程中，做了一些逻辑题，很多题还是很有意思的，在做这种类型题目的过程中能找到一些乐趣，于是打算和我的室友庆哥一起，将网上流行的一些有趣的逻辑思考题整理一下，附上我们的答案，和大家一起分享。

答案我都设置成了白色，用鼠标选中后可以看到。

1. 经过加减乘除运算，得到24
10，10，4，4
3，3，8，8
3,3,7,7

答案：(10*10-4)/4; 8/(3-8/3); 7*(3+3/7)

2.平面9个点，过三个连成一条直线，如何放点能连出10条直线

答案：
*___*____*
__*_*_*__
*___*____* 其中星号代表点，下划线当做空格(因为普通空格会被WordPress吃掉，懒得写HTML代码了)

3.医院里的医务人员，包括我在內，总共是16名医生和护士。下面讲到的人员情况，无论是否把我计算在內，都不会有任何变化。在这些医务人员中：
（一）护士多于医生。
（二）男医生多于男护士。
（三）男护士多於女护士。
（四）至少有一位女医生。」
这位说话的人是什么性別和职务？

答案：女护士。先考虑除“我”之外的情况，那么总共是15个人，护士和医生的组合有（8，7）、（9，6）…… 对于（9，6），男医生最多有5个，那么男护士最多4个，女护士最多3个，加起来不够护士数量。同样的道理(10,5)、（11，4）等组合也被排除。所以护士医生组合是(8,7)，而加上“我”之后情况不变，所以“我”肯定是护士。然后考虑男女护士的组合，由于男护士多于女护士，而男护士小于6（因为男医生最多只能是6个），所以男护士只能是5个，女护士3个，为了保持加上“我”之后情况不变，所以“我”只能是女护士

4.有一个圆柱形的透明的标准量杯，但上面没有任何刻度。已知这个量杯装满的水的重量是100克。如何不使用任何辅助器具，仅用这个量杯量出50克的水?
答案：小心的往外倒水，当水平面正好位于杯底的圆顶端和杯口圆底端的切面时即可。

5.一瓶还剩多半的啤酒，只用一把直尺，就量出瓶子里的酒占瓶子容积的几分之几吗？
答案：假设啤酒液面已经到了规则的圆柱体部分（如果液面在不规则的瓶颈部分我们还不知道怎么算），那么难点是要知道瓶颈整个不规则部分占酒瓶容积的比例x，我们可以量出当前液面的高度，然后将酒瓶倒转，再量出一个液面高度，就可以换算出x了。

6.你一个人在一座孤岛上，救援人员十天后才能到达（今天是第0天)。你有A和B两种药片，每种10粒。每天你必须各吃一片才能活到第二天。但是你不小心把两种药片混在一起无法分辩了。你会怎么办？
答案：将所有药片捣碎，均匀混合后每天吃十分之一。

7.S先生、P先生、Q先生他们知道桌子的抽屉里有16张扑克牌：红桃A、Q、4 黑桃J、8、4、2、7、3 草花K、Q、5、4、6 方块A、5。约翰教授从这16张牌中挑出一张牌来，并把这张牌的点数告诉 P先生，把这张牌的花色告诉Q先生。这时，约翰教授问P先生和Q 先生：你们能从已知的点数或花色中推知这张牌是什么牌吗？于是，S先生听到如下的对话：
P先生：我不知道这张牌。
Q先生：我知道你不知道这张牌。
P先生：现在我知道这张牌了。
Q先生：我也知道了。
听罢以上的对话

答案：方块5。从前两句话可以知道这张牌只能是红桃或者方块，因为黑桃和草花都有牌满足P先生知道点数就知道牌面了。然后P先生说他知道了，则点数不可能是A，候选的是红桃Q和4以及方块5，这时候Q先生也知道了，那么只能是方块5了。

8.烧一根不均匀的绳，从头烧到尾总共需要1个小时。现在有若干条材质相同的绳子，问如何用烧绳的方法来计时一个小时十五分钟呢？
答案：将一根绳一端点着，另一根绳两端点着，当两端点着的绳燃尽时是半个小时，这时候把第一根绳的另一端也点着，等他燃尽就是45分钟了，然后再拿根绳子两端点着得到半个小时。

9.给你三个纸杯，10枚硬币，怎样把放这些硬币都放进杯子，使每个杯子里的硬币总数都是奇数？
答案：我不知道怎么做，庆哥给了一个取巧的办法，比如放3，4，3然后把第三个杯子重叠到第二个杯子里。

10.5个海盗抢得100枚金币后，讨论如何进行公正分配。他们商定的分配原则是：
（1）抽签确定各人的分配顺序号码（1，2，3，4，5）；
（2）由抽到1号签的海盗提出分配方案，然后5人进行表决，如果方案得到超过半数的人同意，就按照他的方案进行分配，否则就将1号扔进大海喂鲨鱼；
（3）如果1号被扔进大海，则由2号提出分配方案，然后由剩余的4人进行表决，当且仅当超过半数的人同意时，才会按照他的提案进行分配，否则也将被扔入大海；
（4）依此类推。
这里假设每一个海盗都是绝顶聪明而理性

答案：著名的海盗分金问题。
最后的方案是97,0,1,2,0或者97,0,1,0,2。
我是这么推理的：
倒着来，假如最后只剩4和5的时候，不管4怎么分，5都会不同意，他就得死（除非他全给5，然后5心情还不错:）。现在假设剩下3,4,5, 这时候4为了保命，不管3怎么分，他都会同意的，所以3会全部拿走。然后考虑2来分，4和5知道如果到3分的时候他们什么都得不到，所以只要2分别给4和5一枚金币，他们就会同意。最后考虑1来分，这时候3知道如果轮到2分的话他什么都得不到，所以1只要给3一个金币，他就会同意，对于4和5，他们也知道如果轮到2分的话只能得到一枚金币，所以1只要给4或者5两枚金币就可以再买一票。

11.一个教授逻辑学的教授，有三个学生，而且三个学生均非常聪明！一天教授给他们出了一个题，教授在每个人脑门上贴了一张纸条并告诉他们，每个人的纸条上都写了一个正整数，且某两个数的和等于第三个！（每个人可以看见另两个数，但看不见自己的）
教授问第一个学生：你能猜出自己的数吗？回答：不能；
问第二个，不能；
第三个，不能；
再问第一个，不能；
第二个，不能；
第三个：我猜出来了，144！
教授很满意的笑了。请问您能猜出另外两个人的数吗？请说出理由！

答案：36，108，144（这个题挺难的，我算了一个多小时用了两页A4纸才算出来，以后有时间可以专门就这道题写一篇日志）

《编程之美》2.20程序理解和时间分析

madongfly — Wed, 01 Sep 2010 18:12:35 +0800

最近在看《编程之美》，为找工作面试做准备。该书中2.20程序理解和时间分析一题没有给出解答，所以简单写一下我自己的答案。

题目如下：
阅读以下C#代码，回答问题：

using System;
using System.Collections.Generic;
using System.Text;
 
namespace FindTheNumber
{
     class Program
     {
          static void Main(string[] args)
          {
               int [] rg =
               {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};
 
               for(Int64 i = 1; i < Int64.MaxValue; i++)
               {
                    int hit = 0;
                    int hit1 = -1;
                    int hit2 = -1;
                    for (int j = 0; (j < rg.Length) && (hit <= 2); j++)
                    {
                          if((i % rg[j]) != 0)
                          {
                               hit++;
                               if(hit == 1)
                               {
                                    hit1 = j;
                               }
                               else if (hit == 2)
                               {
                                    hit2 = j;
                               }
                               else
                                    break; 
 
                          }
                    }
 
                    if((hit == 2) && (hit1 + 1 == hit2))
                    {
                          Console.WriteLine("found {0}", i);
                    }
 
               }
          }
     }
}

1> 这个程序要找的是符合什么条件的数？
2> 这样的数存在么？符合这一条件的最小的数是什么？
3> 在电脑上运行这一程序，你估计要多长时间才能输出第一个结果？时间精确到分钟(电脑配置：单核CPU2.0GHz，内存和硬盘资源充足)

我的解答：

1> 第一个问题不难，只要认真分析程序，就能看出来程序求的是这样的数，这个数不能被 rg[k]和rg[k+1]整除(0 <= k < n-1)，同时能被其余所有数(即rg[0],…,rg[k-1]和r[k+2],…,r[n-1])整除。

2> 该问的入手点是寻找rg[k]和rg[k+1]。

首先，rg[k]肯定大于15。若rg[k]<=15的话，那么rg[k]*2也在rg数组中，并且不能被 i 整除，所以这样的 i 肯定找不到。

其次，rg[k]和rg[k+1]不能由其余的rg数组中的数组合相乘而得，比如18，可以由2乘上9得到，所以若 i 能整除 2 和 9, 则必能整除18. 由此，我们可以得到：

16=2*8, 18 = 2*9, 20 = 4*5, 22 = 2*11, 24 = 3*8, 26 = 2*13, 28 = 4*7, 30 = 2*15。

这样乍一看，似乎没有满足条件的rg[k]和rg[k+1]，但是我们注意在上述一串等式中，16=2*8，其中的2是8的因子，所以只要 i 能整除8，就必能整除2，因此没有必要要求 i 能整除 2*8。而其余的等式中，两个乘数没有因子关系，所以i 若能整除两个乘数，则肯定能整除其乘积。

由此，我们得到了唯一满足条件的rg[k]和rg[k+1]，即16,17。

这样，剩下的问题就是求不能整除16,17，却能整除其余所有数的整数中最小的那一个。我们先把2到31中的素数都列出来(17除外)：{2,3,5,7,11,13,19,23,29,31}。而2到31中(16,17除外)的数都是由这些素数作为因子组合相乘得到的，其中，要得到8，至少要3个2，要得到27至少要3个3，要得到25，至少要2个5，其余的素因子都只需一个就够了。

因此，这个最小的数就是 2^3, 3^3, 5^2, 7, 11, 13, 19, 23, 29, 31的乘积，答案为：2123581660200。（因为题目要求不借助电脑，所以我手算了两次，竟然都算错了，最后只好拿计算器算）。

3> 要估算时间，我们先确定一个原子操作（或者说原子过程更合适），这里我们取内层for循环里的整个if语句块，该段程序主要包括一个取模操作和一个判断，如果进入if语句的话，还包括1次加法操作，1~2次判断和一次赋值操作。

我们知道加法、判断等操作基本都在几个时钟周期内就可以完成，而除法操作却需要数十个时钟周期，而取模操作也是通过除法操作得到的(还记得汇编语言里，执行除法操作之后，一个寄存器里存结果，另一个寄存器里存余数)，另外，对64位整数的除法明显要慢于32位整数，综合这些因素，我们可以假设该原子操作需要100个时钟周期。因此2GHz的CPU在1秒内能跑2*10^9 / 100 = 2*10^7 即2000万次原子操作，做过ACM的同学就会有一个直观概念，这和我们通常做时限为1S的题时估算的计算次数差不多。

接下来估算原子操作执行的次数：外层循环跑了2123581660200次，内层循环取决于 i 的情况，当i为奇数的时候，内层最多跑5次即可结束，因为2，4，6都不能整除奇数；当i为偶数的时候，情况要复杂一些，但是也可以一个一个的详细分析。这里我们粗略估计，就算内层循环平均可以跑10次，外层循环少跑一些，去掉零头，总的原子操作执行了2*10^13次。

所以需要 2*10^13 / (2*10^7) = 10^6秒约为277个小时。

《CSAPP深入理解计算机系统》读后标记

madongfly — Tue, 31 Aug 2010 10:35:29 +0800

陆陆续续花了一个月的时间，终于看完了CSAPP(Computer System：A programmer‘s perspective 注：第二版已出：英文版中文版)，头一次看那么厚(900页)的原版书，看完还是有一点点成就感的。

从同宿舍的鲁博士那里第一次听说这本书，了解到该书从一个程序员的视角详细剖析了整个计算机系统，涵盖了组成原理、汇编语言、体系结构、操作系统、网络等计算机基础知识，当时就决定找工作之前一定要看看这本书，现在终于搞定，也算是间接复习了一下前述几门课程。

这次阅读用的是鲁博士的书，再次印证了买来的书没有借来的书看得彻底的“真理”……

在阅读过程中，对该书的各个章节做了一些标注，以备将来重新翻阅的时候参考。这些标注主要从两个角度进行，一是对我找工作应试（包括笔试和面试）有没有用，二是对我自身的技术提高有没有用，所以分为应试和修炼两个指标，参照流行的打分标准将其分为从★到★★★★★五个等级。现记录如下：

Chapter 1
A Tour of Computer System

一个对计算机系统总体的介绍，简单明了。

应试 ★★★：可能在笔试中会有一些整体上的概念题。
修炼 ★: 属于计算机最基本的概念。

chapter 2
Representing and Manipulating Information

信息在计算机中的表示形式。分别包括整数和浮点数的表示形式。

应试 ★: 应试中很少会考到。
修炼 ★★★★：有很多人可能写了多年的代码都不知道浮点数是如何用那4（8）个字节存储的。

chapter 3
Machine-Level Representation of Program

汇编语言的复习。

修炼 ★★★★★：理解汇编语言和寄存器结构是后面很多内容的基础。

应试：
3.7 Procedures ★★★★★：过程调用，尤其是过程调用（包括递归调用）中堆栈的使用情况是经常会考到的。
3.10 Alignment ★★★★★：数据在内存中的“对齐”方式，也是经常出现在考题中的。比如定义一个结构体数组，打印出其中一个元素的地址，问这个地址相对数组起始地址有多少个字节的距离。
others ★★★：汇编在应试中考的还是比较少的（除专门的职位）。

chapter 4
Processor Architecture

计算机体系结构的内容。
处理器结构，各种逻辑门、功能单元，指令集，指令的执行，指令执行的流水线等。

应试 ★：对于软件相关职位来说，很少会考到这么底层的东西的。
修炼 ★★★：对于从事软件层面的技术人员来说，不用深入，但是也应该理解，知道是怎么回事。

chapter 5
Optimizing Program Performance

如何优化程序的执行效率，包括代码的优化，编译器的优化，及CPU级别的优化。

5.1-5.6
应试 ★★★★：经常会有一些让你寻找程序瑕疵的问题，你能看出代码在哪些细节上可以优化吗？
修炼 ★★★★★：你当然需要知道编译器能在什么层面上自动帮你优化代码，在编译器无法优化时你自己如何在小细节上优化代码。

5.7以后
CPU级别的优化，微指令的概念，功能单元上微指令的并行，程序分支的预测等。
应试 ★：对于软件相关职位来说，不会考这些东西的。
修炼 ★★★：不用深入，但是应该知道并能够理解。

chapter6
The Memory Hierarchy
详细介绍了计算机系统中的存储结构。

6.1 介绍了不同种类的存储设备以及对应的存取数据的方式。
应试 ★：很少会考到这么底层的东西
修炼 ★★：知道就好了。

6.2-6.5 介绍了存储设备的组织形式，着重介绍了Cache及其工作方式。
应试 ★★★★：在面试中，经常会考到跟cache相关的题目。
修炼 ★★★★：存储结构和cache是计算机中很基础也很重要的概念。

6.6-6.7 介绍了程序如何和cache打交道，不同的循环嵌套顺序、遍历方向等对cache命中的影响。
应试 ★★：很少会考到这些东西。
修炼 ★★★★：你当然希望在写多重循环的时候知道什么样的嵌套顺序效率最高。

chapter 7
Linking
顾名思义，详细讲解了程序的链接过程，主要分为静态链接和动态链接，以及链接过程中使用到的技术。

应试 ★★★：需要知道链接的基本概念，尤其是动态链接可能会考到。
修炼 ★★★★★：有的时候，你很可能会被一个链接错误折磨好几天。另外，动态链接库的应用现在也是很普遍的。

chapter 8
Exceptional Control Flow
顾名思义，本章主要讲解异常控制，不过这里的“异常”并不是Java或者C++里的狭义的异常，而是一个广义的“Exceptions”的概念，包括中断（Interrupt，硬件层面，主要是I/O中断），陷阱(Trap,主动产生的异常，主要用于用户程序和系统内核间的交互，如系统调用)，错误（Falut，如除0错误；页错误：在虚拟内存中，所请求页面并不在内存中，需要从硬盘读取等。错误可能恢复），中止（Abort，致命错误，无法恢复，如硬件问题等）。
在介绍异常处理的同时，引入了进程的概念，对进程控制也进行了详细介绍，以及进程级别的Exception：信号（signal）,这个级别的异常处理由操作系统完成，通常叫做上下文切换（context switch）。
应试 ★★：主要掌握进程的概念即可。
修炼 ★★★：知道异常控制流是怎么回事，用户程序和系统交互（如系统调用）的原理和方式即可，不用太深入。

chapter 9
Measuring Program Execution Time
本章介绍了如何尽可能准确的测量程序执行的时间。在实际编程中，我们极少会需要进行如此精确的测量，所以我跳过本章不读。

chapter 10
Virtual Memory
非常重要的一章，虚拟存储机制是计算机实现多任务的一项重要技术。计算机正是通过时间片技术使得每个进程在执行时仿佛独占CPU，进而又通过虚拟存储机制使得每一个进程在执行时，仿佛独占内存。
10.1介绍了虚拟地址和物理地址，CPU进行寻址操作产生的是虚拟地址，通过存储管理单元（memory management unit）转换为实际的物理内存地址。
10.3~10.5讲述了虚拟存储机制的优点：使得内存可以作为硬盘的cache；能够更方便的管理内存；能更好的提供内存保护机制。
10.6 介绍了虚拟地址如何转换为物理地址。
10.7 很精彩的一节，通过Intel Pentium和Linux的实例讲述了整个存储管理机制。记得以前上操作系统课的时候，各种理论、机制学了一大堆，但是就是不知道实际的操作系统到底用的哪套方法。而本节内容正是通过实例让你对刚学的理论机制有一个直观的了解。
10.8~10.10 讲述了存储映射（Memory Mapping）、动态内存分配和垃圾回收机制。
10.11 很实用的一节，列举了一些C编程中容易犯的内存引用错误。

应试 ★★★★：本章内容是操作系统课程的重点内容，如果考操作系统，极有可能考到。10.11节的知识也能帮你应对一些程序挑错题。
修炼 ★★★★★：操作系统中重要的基础内容，即使你只使用Java这样的高级编程语言，至少也应该弄懂垃圾回收机制吧。

chapter 11
System-Level I/O
介绍类Unix系统下的I/O读写，主要介绍系统层面的I/O接口。由于我们日常编程所用的I/O接口都是各种高级语言提供的经过封装的标准接口，故而如果不进行嵌入式编程的话这部分知识不是必须的，我跳过没读。

chapter 12
Network Progranmming
简单介绍了网络模型，TCP/IP协议，类Unix系统的socket接口等。
应试和修炼 ★★：因为篇幅限制，本章只做了简单讲解，要掌握网络编程知识还需要参考专门的网络技术书籍。

chapter 13
Concurrent Programming
本章简单介绍了并发程序设计的内容，主要包括：
进程级别的并发，各子进程拥有不同的虚拟地址空间，需要IPC(InterProcess Communication)机制共享数据，进程之间切换开销大。
I/O复用，事件驱动，单进程运行，共享虚拟地址空间，并发效果不理想。
线程，介于上述两种中间，各子线程共享进程的虚拟地址空间，线程间切换开销较小。

另外介绍了并发编程中访问共享变量的信号量机制。给出了4类容易引起线程不安全的函数。
应试 ★★：除应聘相关职位外，并发编程考的比较少，不过需要清楚锁机制和信号量机制等。
修炼 ★★★：多线程程序在现今的开发中还是很常见的，但是本章介绍的比较简单，需要参考另外专门的书籍。

计算机中浮点数的舍入

madongfly — Fri, 06 Aug 2010 16:57:50 +0800

学过计算机组成原理的同学都知道在计算机中，浮点数是通过3个部分来表征的，1个bit的符号位，k个bit的指数位和n个bit的有效数位，对于C语言中的float和double，k、n值分别是8、23和11、52。

我们可以想象一下，表征浮点数的bit是有限的，因而其组合也是有限的，是无法完全表征所有实数的，事实上，连一些10进制下看上去很简单的数也都无法精确表示。比如，你可以试一下下面几行代码：

#include <stdio.h>
int main()
{
	double a = 0.1;
	printf("%.20lf",a);
	return 0;
}

你会看到输出的其实是0.10000000000000001000。

正是由于很多实数无法精确表示，所以在计算机处理浮点数的时候，需要进行大量的舍入操作，那么计算机默认是采用什么样的舍入策略呢？

以前我一直以为计算机采用的就是人们日常所熟悉的“四舍五入”法则，因为在printf函数中，如果指定输出精度小于实际精度的话，输出的结果就是按四舍五入产生的。其实这是printf函数故意设计成这样以符合人们的日常习惯的。

实际计算机中，当需要进行舍入操作时，运用是一种叫“round-to-even”的策略，即“向偶数舍入”，举个简单的例子就可以明白了，比如1.235和1.245，舍入后都是1.24, 也就是说要使得舍入后的最后一位有效数字是偶数。

为什么要采用这样的策略，而不直接使用我们已经习惯的“四舍五入”呢。原因在于，在进行舍入的时候，最后一位数字从1到9, 舍去的有1,2,3,4；正好可以和进位的9,8,7,6相对应，而5却被单独出来了，如果我们采用四舍五入每次都将5进位的话，在进行一些大量数据的统计时，就会累积比较大的偏差，而如果采用”round-to-even”的策略，在巨大多数情况下，5舍去还是进位的几率差不多，统计时产生的偏差也就相应要少一些了。

快速看懂简单perl代码

madongfly — Wed, 28 Jul 2010 17:40:58 +0800

最近在实现PLSV，写了一个matlab的版本，效果却远没有原作者论文上说的好。

给作者发信索要代码，答曰：本人已在公司工作，出于保密，不能给你代码，不过在这个网页(需翻墙)上有别人写的代码，你可以看一看。

看了那个blog上的代码，是一个日本人写的perl代码，一看代码风格很严谨，遂认为是精品，于是慢慢品读，但因为我是头一次读perl的代码，所以边看边查，做了一点记录。

代码太长，附在文章最后吧，先是我做的一点记录：

#!/usr/bin/perl
这一行是Linux类系统下脚本的第一行，指定脚本执行环境，python也有。

use
导入模块，类似java的import

定义变量，直接使用一个$符号，比如$a，就表示定义了一个名为a的标量。这个不管是int，float，string，char……一律使用这个表示。
定义数组，直接使用符号@，比如@array，表示定义一个名为array的数组。基本上和上面的差不多，但是perl中好像是没有直接的二维数组的定义。
定义Hash，使用符号%，比如%hash，表示定义一个名为hash的哈希结构。哈希结构基本上在前期用的不多，在后面的时候，可以和数组组合成比较强大的结构体。

our、my
定义变量的关键字，具体含义还没有深究，先简单的把它当做matlab里的global。

shift函数
原型：shift ARRAY；把数组的第一个值移出并且返回它，然后把数组长度减一并且把所有的东西都顺移。如果在数组中不再存在元素，它返回 undef。如果省略了 ARRAY，那么该函数在子过程和格式的词法范围里移动 @_；它在文件范围（通常是主程序）里移动 @ARGV

@_是子程序的参数列表，@ARGV从名字上就能猜到是命令行参数。our $input = shift 这条语句也就是得到第一个参数，也就是文件名。

open(F, “$input”) 。从名字上就能看出这是打开一个文件。

chomp 函数，去掉字符串末尾的换行符。默认对$_进行操作，$_是什么没时间深究，从程序上下文来看，应该就是打开文件中的每一行。这个while循环就是把文件里每个词取出来，存入词频表W。

our $wordsize = (keys %W); 显然，获得词的数目。不过为什么还要用括号括起来呢？猜测keys %W是得到W的key的集合，然后括号是得到这个集合的个数。简单查了一下好像的确是这样的。

到这儿之后，接下来的代码都是跟PLSV的算法相关的了，根据关键字的名称，基本可以顺利读下去了，我也就懒得再整理了。

其实吧，我懒得再整理的真正原因，是因为到这儿看到了几个核心函数之后，发现作者的实现方式可谓“绝对暴力”，完全没有任何优化，循环里面嵌套没必要的循环，这让我对该代码产生了怀疑……

完全浏览之后，果然大失所望，在该算法最核心的部分，作者根本就没有用到论文中说的拟牛顿法，而是自己用了一个简单粗暴的梯度下降法，并且如果严格按论文来说的话，该梯度的计算还是错的……

不过失望之余，还是很佩服日本人的严谨，从算法功能和实现上来说，该代码可谓低级，但是编程风格确实是很不错的，能把这么低级的实现用这么认真的风格写出来，还是很需要勇气的……

#!/usr/bin/perl
# Probabilistic Latent Semantic Visualization
# Copyright (c) 2009, Kei Uchiumi
 
use warnings;
use strict;
 
# Usage
# perl plsv.pl corpus
 
our $dimension = 2;
our $topicsize = 2;
our $alpha = 0.01;
our $beta = 0.0001;
our $ganma = 0.0001 * $topicsize;
our $docnum = 0; # document size N
our $iteration = 50;
 
# for sgd parameters
our $rate = 0.1; # learning rate
our $input = shift;
 
my %W;
 
open(F, "$input") or die "Couldn't open $input $!";
while ()
{
   chomp;
   my $line = $_;
   my @tokens = split(/\s/,$line);
   &storeword(\%W, \@tokens);
   $docnum++;
}
close(F);
 
our $wordsize = (keys %W);
$beta = $beta * $docnum;
 
# init parameters
our %theta;
our %phi;
our %xai;
 
# init phi
for (my $i = 0; $i < $topicsize; $i++)
{
   my @position;
   for (my $d = 0; $d < $dimension; $d++)
   {
      #$position[$d] = rand;
      $position[$d] = 1;
   }
   $phi{$i} = \@position;
}
# init xai
for (my $i = 0; $i < $docnum; $i++)
{
   my @position;
   for (my $d = 0; $d < $dimension; $d++)
   {
      $position[$d] = 0;
   }
   $xai{$i} = \@position;
}
# init theta
for (my $i = 0; $i < $topicsize; $i++)
{
   my @words;
   my $denominator = 0;
   for (my $j = 0; $j < $wordsize; $j++)
   {
      $words[$j] = -log(1.0 - rand);
      $denominator += $words[$j];
   }
   for (my $j = 0; $j < $wordsize; $j++)
   {
      $words[$j] = $words[$j] / $denominator;
   }
   $theta{$i} = \@words;
}
 
our %prob_zpx;
our %prob_zpnm;
 
# learning start
for (my $i = 0; $i < $iteration; $i++)
{
   &expectation($input);
   &maximization($input);
}
 
# output
use Data::Dumper;
print "Result\n";
print "Phi\n";
print Dumper(%phi);
print "Xai\n";
print Dumper(%xai);
print "Theta\n";
print Dumper(%theta);
 
# functions
sub xaiupdate
{
   my $docid = shift;
   my $topic = shift;
   my $grad = shift;
 
   my $x = $xai{$docid};
   my $p = $phi{$topic};
 
   for (my $i = 0; $i < $dimension; $i++)
   {
      my $diff = $grad * ($x->[$i] - $p->[$i]) - $ganma * $x->[$i];
      $x->[$i] += $rate * $diff;
   }
   return;
}
 
sub phiupdate
{
   my $docid = shift;
   my $topic = shift;
   my $grad = shift;
 
   my $x = $xai{$docid};
   my $p = $phi{$topic};
 
   for (my $i = 0; $i < $dimension; $i++)
   {
      my $diff = $grad * ($p->[$i] - $x->[$i]) - $beta * $p->[$i];
      $p->[$i] += $rate * $diff;
   }
   return;
}
 
sub update
{
   my $input = shift;
 
   my $docid = 0;
   open(F,"$input") or die "Couldn't open $input $!";
   while ()
   {
      chomp;
      my $line = $_;
      my @tokens = split(/\s/,$line);
 
      my $p_zpnm = $prob_zpnm{$docid};
      for (my $i = 0; $i < @tokens; $i++)
      {
         my $p_znm = $p_zpnm->{$i};
         for (my $j = 0; $j < $topicsize; $j++)
         {
            my $p_zpx = $prob_zpx{$docid}->[$j];
            my $p_z = $p_znm->[$j];
            my $grad = $p_zpx - $p_z;
            &xaiupdate($docid,$j,$grad);
            &phiupdate($docid,$j,$grad);
         }
      }
      $docid++;
   }
   close(F);
}
 
sub thetaupdate
{
   my $input = shift;
   my $topic = shift;
   my $word = shift;
 
   my $numerator = 0;
   my $denominator = 0;
   my $docid = 0;
   open(F,"$input") or die "Couldn't open $input $!";
   while ()
   {
      chomp;
      my $line = $_;
      my @tokens = split(/\s/,$line);
 
      my $p_zpnm = $prob_zpnm{$docid};
      for (my $i = 0; $i < @tokens; $i++)
      {
         my $p_znm = $p_zpnm->{$i};
         if ($tokens[$i] eq $word)
         {
            $numerator += $p_znm->[$topic];
         }
         $denominator += $p_znm->[$topic];
      }
      $docid++;
   }
   close(F);
 
   return ($numerator+$alpha)/($denominator+$alpha*$wordsize);
}
 
sub maximization
{
   my $input = shift;
# theta update
   for (my $i = 0; $i < $topicsize; $i++)
   {
      for (my $j = 0; $j < $wordsize; $j++)
      {
         $theta{$i}->[$j] = &thetaupdate($input,$i,$j);
      }
   }
# xai, phi update
   &update($input);
 
   return;
}
 
sub euclid
{
   my $topic = shift;
   my $docid = shift;
 
   my $docpositions = $xai{$docid};
   my $topicpositions = $phi{$topic};
 
   my $d = 0;
   for (my $i = 0; $i < $dimension; $i++)
   {
      my $diff = $docpositions->[$i] - $topicpositions->[$i];
      $d += $diff * $diff;
   }
 
   return $d;
}
 
sub dist
{
   my $topic = shift;
   my $docid = shift;
 
   my $denominator = 0;
   for (my $i = 0; $i < $topicsize; $i++)
   {
      $denominator += exp(-1/2 * &euclid($i, $docid));
   }
   my $numerator = exp(-1/2 * &euclid($topic, $docid));
 
   return $numerator/$denominator;
}
 
sub posterior
{
   my $docid = shift;
   my $topic = shift;
   my $word = shift;
 
   my $p_zpx = $prob_zpx{$docid};
   my $denominator = 0;
   for (my $i = 0; $i < $topicsize; $i++)
   {
      $denominator += $p_zpx->[$i] * $theta{$i}->[$word];
   }
   my $numerator = $p_zpx->[$topic] * $theta{$topic}->[$word];
 
   return $numerator/$denominator;
}
 
sub expectation
{
   my $input = shift;
   for (my $i = 0; $i < $docnum; $i++)
   {
      my @probs;
      for (my $j = 0; $j < $topicsize; $j++)
      {
         my $prob = &dist($j,$i);
         $probs[$j] = $prob;
      }
      $prob_zpx{$i} = \@probs;
   }
 
   my $docid = 0;
   open(F,"$input") or die "Couldn't open $input $!";
   while ()
   {
      chomp;
      my $line = $_;
      my @tokens = split(/\s/,$line);
 
      my %probs_znm;
      for (my $i = 0; $i < @tokens; $i++)
      {
         my @probs;
         for (my $j = 0; $j < $topicsize; $j++)
         {
            my $p = &posterior($docid, $j, $tokens[$i]);
            $probs[$j] = $p;
         }
         $probs_znm{$i} = \@probs;
      }
 
      $prob_zpnm{$docid} = \%probs_znm;
      $docid++;
   }
   close(F);
   return;
}
 
sub storeword
{
   my $wh = shift;
   my $ta = shift;
 
   foreach my $w (@$ta)
   {
      unless (defined $wh->{$w})
      {
         $wh->{$w} = 1;
      }
   }
   return;
}

《独唱团》末尾漫画《The Darkness outside night》的理解

madongfly — Tue, 13 Jul 2010 18:23:26 +0800

昨天拿到的《独唱团》，看了几篇文章，很有感触，以后有时间再慢慢写评论。

其实我觉得《独唱团》里最有深意的就是几篇漫画了，毕竟为了杂志的出版，文字还是不能太背离主旋律的，而几篇漫画笔法虽简单，却都蕴含了一些深意。尤其最后一篇漫画《The Darkness outside night》，我看第一遍的时候就产生了强烈的共鸣，反复看了好几遍之后，一种莫名的悲哀便难以抑制的漫上心头。

好了，在在这里说一下我的理解吧：

我们就像是生活在一个玻璃瓶里的苍蝇，当我们还小的时候，我们在这个狭小的空间里缓缓地畅游，透过透明的玻璃，我们可以看到绚烂的阳光和五彩的霞云，我们以为整个世界都是我们的。终于有一天，我们发现了禁锢住我们的玻璃瓶，惊诧莫名的同时，我们感到异常的愤怒，在这个光明的世界里怎么能有这样一堵无形的墙存在呢，于是我们开始想尽一切办法冲破这堵禁锢我们自由的墙，结果，我们被撞得头破血流。在四处碰壁之后，我们终于妥协了，默默的接受了这个现实，这个时候，一个出口出现了，通过这个出口，已经妥协的我们终于走出了玻璃瓶，来到了一个肮脏世界的垃圾场，变成了一只真正的苍蝇……

漫画的最后一页，在一个肮脏城市的垃圾场背景下，写着“我的奋斗”，也许，这正是很多人奋斗史的写照……

用Java自己实现链表

madongfly — Fri, 23 Apr 2010 15:06:17 +0800

先再次感叹一下自己的Java没学好……

以前本科上Java课的时候，记得最清楚地一件事就是Java里没有指针，当时曾经疑惑过，那怎么用Java写链表呢。但是也没有深想，后来要用到也是一直用像List，vector这样的现成结构。

直到最近用Java用得比较多，才逐渐搞清楚了Java中对象引用的概念，于是想到其实可以通过对象引用实现链表。写了个小程序测试一下，果然OK。

public class Node {
	int i;
	Node next;
	Node(int ref) {
		i = ref;
		next = null;
	}
}
 
public class LinkTest {
	public static void main(String[] args) {
		Node head = new Node(0);
		Node p = head;
		for(int i = 1; i <= 10; i++){
			Node tmp = new Node(i);
			p.next = tmp;
			p = tmp;
		}
		p = head;
		while(p != null){
			System.out.print(p.i+" ");
			p = p.next;
		}
	}
}

这里用到的java中的对象引用概念，指的是在Java中，除了基础类型（int,float之类）之外，对象使用赋值符号时，都是将右边对象的一个引用给了左边的变量。

madongfly的天空

我的2010年终总结

相关日志

为求职事致谢

相关日志

有趣的逻辑推理题–2

相关日志

有趣的逻辑思考题–1

相关日志

《编程之美》2.20程序理解和时间分析

我的解答：

相关日志

《CSAPP深入理解计算机系统》读后标记

相关日志

计算机中浮点数的舍入

相关日志

快速看懂简单perl代码

相关日志

《独唱团》末尾漫画《The Darkness outside night》的理解

相关日志

用Java自己实现链表

相关日志