Princetonboy http://princetonboy.ycool.com/ Fri, 03 Jul 2009 15:07:31 GMT Fri, 03 Jul 2009 15:07:31 GMT http://sta.yculblog.com/images/logo/general-88x31.gif Princetonboy http://princetonboy.ycool.com/ 生活的忠告 http://princetonboy.ycool.com/post.3430761.html PS:一个朋友发给我的网页文字,其实很早以前看过,今天同样认真的读了一遍,且不说是否迷信,是否读了之后会有好运,但是其中的话却真的有深刻的道理. 生活,我们该以一个什么样的态度去面对呢? 这是一个值得用一生去思考的问题.
 
印度的密教经典－－古老的祝福
不管你是否迷信,这个网页都应该读一下,好吗?
这是密教图腾上的文字.
读了这封信后的四天内,你会有好运来临.
把这封信邮寄给几个你想要祝福的人. 有许许多多人,也许你已经淡忘了,如果仍然在你的心里,他们也一样会得到幸运.
我不会给你钱,因为我没有.
 
给你生活的忠告:
多吃些粗粮.
给别人比他们自己期许的更多,并且用心去做.
熟记你喜欢的诗歌.
不要轻信你听到的每件事,不要花光你的所有,不要想睡多久就睡多久.
无论何时说“我爱你”,请真心实意.
无论何时说“对不起”,请看着对方的眼睛.
相信一见钟情.
永远不要忽视别人的梦想.
深情热烈地爱,也许你会受伤,但这是使人生完整的唯一方法.
用一种明确的方法解决争议,不要冒犯.
永远不要以貌取人. 慢慢地说,但要迅速地想.
当别人问你不想回答的问题时,笑着说“你为什么想知道?”.
记住那些敢于承担最大风险的人才能得到最深的爱和最大的成就.
给妈妈打电话. 如果不行,至少在心里想着她.
当别人打喷嚏时,说一声“菩萨保佑”.
如果你失败了,千万不要忘记汲取教训.
记住三个“尊”: 尊重你自己; 尊重别人; 保持尊严,对自己的行为负责.
不要让小小的争端损毁了一段伟大的友谊.
无论何时你发现自己做错了,竭尽所能去弥补. 动作要快!
无论什么时候打电话,摘起话筒的时候请微笑,因为对方能感觉到!
找一个你爱聊的人结婚,因为当年龄大了以后,你会发觉喜欢聊天是一个人最大的优点.
找点时间,单独呆会儿.
欣然接收改变,但是不要摒弃你的个人理念.
记住,沉默是金.
多看点书,少看点电视.
过一种高尚而诚实的生活. 当你年老时回想起过去,你就能再一次享受人生.
相信上帝,但是别忘了锁门.
家庭的融洽氛围是难能可贵的.
尽你的全力让家平顺和谐.
当你和你亲近的人吵嘴的时候,试着就事论事,不要扯出那些陈芝麻,烂谷子的事.
不要摆脱不了昨天.
多注意言下之意.
和别人分享你的知识,那才是永恒之道!
善待我们的地球.
不要愚弄自然母亲。
忙自己该做的事.
不要相信接吻时从不闭眼的伴侣.
每年至少去一个你从没去过的地方.
如果你赚了很多钱,在活着的时候多行善事. 这是你能得到的最好回报.
记住有时候,不是最好的收获也是一种好运.
深刻理解所有的规则,合理地更新他们.
记住: 最好的关系存在于对别人的爱胜于对别人的索求之上.
回头看看你发誓取得的目标,然后评判你到底有多成功.
无论是烹调还是爱情,都用百分之百的负责态度对待,但是不要期求太多的回报.
 
... ]]> http://princetonboy.ycool.com/post.3430761.html Fri, 03 Jul 2009 14:07:26 GMT 祝福 忠告 重归故里 http://princetonboy.ycool.com/post.3397893.html TopCoder

... ]]> http://princetonboy.ycool.com/post.3397893.html Fri, 26 Jun 2009 15:06:05 GMT topcoder acm/icpc 有几个人可以像林志颖这样 http://princetonboy.ycool.com/post.3163929.html 10岁 ------ 遥控车比赛全台湾亚军, 对记者说自己的梦想是做一名赛车手.
 
15岁 ------ 依靠打工买下平生第一辆车(一辆50CC摩托车),并自己动手改装,使之能发出8种声音.
 
15岁 ------ 尚未出道的林志颖因完美的外形和健康阳光的气质被广告商拉去拍了三个大广告---白兰洗面乳、宏基电脑、金车麦根沙士.
 
16岁 ------ 因演出学校舞台剧, 最后5分钟出场, 被飞碟公司星探发现, 正式签约飞碟唱片公司.
 
17岁 ------ 发第一张唱片, 正式出道, 一年不到, 红遍东南亚以及整个华语世界, 绰号“亚洲小旋风”, 被媒体称为娱乐圈“最神的神话”.
 
18岁 ------ 成为第一个完全以国语歌曲演唱入主红磡体育馆歌手及红磡开唱最年轻歌手(该记录至今仍然由林志颖保持). 第一次来访香港的林志颖, 使得香港启德机场经历了十年来一次难得的轰动经验, 一种外来的震撼, 从没这样的颠倒过, 被香港媒体称为“过江龙”.
 
18岁 ------ 举办世界巡回演唱会的最年轻歌手记录保持者.
 
18岁 ------ 拥有第一辆宝马跑车.
 
18岁 ------ 成立自己的摄影工作室(分店一度开到六七家,月盈额200万).
 
20岁 ------ 7张唱片销量全球突破1000万张.
 
20岁 ------ 抛下巨星光环, 毅然入伍当兵.
 
22岁 ------ 以跳箱、射击、投弹、匍匐等等几乎所有项目接近满分, 在役期间荣获四次荣誉假, 并获得“总统奖”嘉许的成绩退伍.
 
22岁 ------ 接受泰国国王莆眉篷的邀请担任莆眉篷70岁大寿生日会演唱压轴嘉宾, 并接受泰国王后和公主的接见, 公主一见钟情, 差点成为泰国驸马.
 
22岁 ------ 开始投资股票.
 
23岁 ------ 拥有第一辆法拉利, 用自己的红色法拉利战车, 第一次赛车比赛拿到季军奖杯.
 
23岁 ------ 巨星身价签约香港百代EMI唱片公司.(报纸写的是两年三千万港币)
 
24岁 ------ 赛车出车祸, 右脚掌断了三根骨头, 打了四根钢钉固定.
 
24岁 ------ 参加世界国际A级越野赛, 成台湾第一个参加国际顶级赛事的车手.
 
24岁 ------ 以一百分的成绩取得专业救护资格证, 成为台湾第一批EMT(Emergency Medical Technician,即紧急救护技术员)之一.
 
25岁 ------ 拍摄第一部电视剧《绝代双骄》, 泰国收视第一, 红遍两岸三地, 再次成为台湾身价片酬最高艺人.
 
25岁 ------ 成立自己的第一支赛车队ESSO JIMMY RACING TEAM.
 
25岁 ------ 一年内四次刷新台湾龙潭BMW M3最快赛车单圈记录.
 
25岁 ------ 潜水执照. (注: 是这一年在新闻中提到潜水执照. 在垦丁海域潜水、飙水上摩托车、玩机械帆船等水上活动, 其实是林志颖学生时代便热衷的.)
 
26岁 ------ 出演电影《红字》, 拿到亚太影展最佳男演员特别奖,《红字》一剧拿下当年泰国年度票房第一,也是泰国历史上总票房排第二的电影.
 
26岁 ------ 在珠海赛车场拿到赛车生涯第一个冠军.
 
26岁 ------ 成立自己的科技公司. (林志颖之后很长一段时间内一直亲历亲为, 与朋友一起将公司发展壮大,甚至在内地拍戏时还坚持每天开远程会议, 处理台北公司事宜. 公司设计软件接冾的对象包括军方、银行等, 是全台湾唯一一家做该方面项目的公司.)
 
27岁 ------ 担任美国国际反毒大使(亚裔艺人第一人).
 
27岁 ------ 赛车达到颠峰状态, 拿到9座职业车赛奖杯, 7个冠军奖杯, 2座亚军, 并成为台湾年度冠军车手.
 
27岁 ------ 成为台湾第一位授薪职业赛车手.
 
28岁 ------ 美国总统布什授予白宫荣誉奖章.
 
29岁 ------ 获得国际杰出青年奖. 是首位华人、全球演艺界继汤姆克鲁斯后第二位艺人获此殊荣. 并于美国领取杰出华人奖, 旧金山定当年10月17日为“林志颖日”, 授予“美国荣誉公民”.
 
29岁 ------ 拍摄《天龙八部》, 为2003年百度年度搜索第一电视剧, 台湾收视最高武侠剧.
 
29岁 ------ 正式投身中国职业汽车拉力赛, 加盟上海佳通轮胎车队.
 
29岁 ------ 搬入装修半年多的居室. (林志颖的家堪一座科技中心. 朋友戏称林志颖过的是007的生活, 家整的像骇客帝国一样, 全是机械化的东西, 说不定从哪里伸出什么东西. 不仅如此, 他家里的电子设备都是和他的手机相连接的, 即便身在美国、内地, 林志颖也可以用手机远程控制家中上百样设备, 比如在回家的路上, 他就可以设定家里的温度、湿度, 可以放水温水这样一回家就能洗澡, 可以在内地招待台北家里的客人等等. 该系统是由他自己的科技公司开发的.)
 
30岁 ------ 加盟云南红河拉力车队, 获得中国拉力赛年度车手第8名. 亚洲雷诺方程式获得第五.
 
30岁 ------ 于珠海举办第一届“林志颖杯“交通安全明星邀请赛, 与好友陈维良先生合作成立“珠海平坐赛车咨询公司”.
 
30岁 ------ 拍《书剑情侠柳三变》时发生意外, 由于吊索的扣环插入, 致使林志颖脊椎旁的一块小骨头骨折. 台湾医生一致建议林志颖至少要休息三个月. 但临时换演员, 意味着剧组要遭受巨大的损失. 林志颖不顾家人反对, 在一个疗程后, 带着强力镇痛药回到了剧组. 不仅如此, 由于治疗耽误了十二天的时间, 此后的拍摄林志颖甚至每天工作十五六个小时为剧组弥补损失.
 
31岁 ------ 组建自己的第一支拉力车队“林志颖车队”, 聘请曾经世界排名第三的英国著名选手小麦克雷为其车队效力.
 
31岁 ------ 改装成了台湾第一把绿色瞄准器的BB枪, 半年后台湾的公司相继效仿生产. (此事在31岁这一年在节目中由朋友爆料, 具体时间不详.)
 
32岁 ------ “林志颖车队”获得中国拉力赛年度季军车队.
 
32岁 ------ 成立“梦飨家”餐厅.
 
32岁 ------ 出演第一部时装偶像剧《放羊的星星》, 为2007年百度年度搜索第一电视剧, 2007年港台最受欢迎电视剧, 及2007年台湾最高收视偶像剧, 并入围2008年韩国首尔电视节最佳长篇电视剧.
 
32岁 ------ 受邀骑哈雷重型机车率领600多辆大排量国内外名牌摩托车和近千名国内摩托车迷于广东江门巡游, 600辆摩托车组成奥运五环, 支持北京奥运会. 该活动经公证创北京奥运组合图案吉尼斯之最.
 
32岁 ------ 担任国际马拉松大使.
 
32岁 ------ 考取游艇执照.
 
32岁 ------ 意大利车商法拉利大手笔包下上海F1赛车场, 提供上亿台币名车, 邀请林志颖担任艺人专业驾驶培训课程教练.
 
33岁 ------ 2008年新飞泛珠三角超级赛车节春季赛第一回合冠军、第二回合亚军, 夏季赛第一回合冠军、第二回合冠军.
 
33岁 ------ 四川汶川地震, 捐款100万人民币(台湾捐款最多艺人), 亲自赴灾区当义工(台湾第一位赴灾区艺人), 认养两名地震孤儿, 08年6月珠海赛事中将试驾所得的钱款全部捐献给赈灾区, 并捐出冠军奖杯义卖.
 
34岁 ------ “挡不住的林志颖”上海演唱会, 2008年10月17日 19:30(P.M)上海虹口足球场.
 
34岁 ------ 2008年10月26日在中国深圳南山后海F1赛场举行加盟中国天荣队仪式, 林志颖正式成为中国队后备队员, 该队是世界F1赛场(F1赛车、F1摩托艇)上唯一的中国队. (演艺圈里首位参与此项殊荣的艺人, 也是香港、台湾地区的首位华人选手)(中国队现计划安排林志颖进行集训和参加F2摩托艇世界锦标赛).
 
... ]]> http://princetonboy.ycool.com/post.3163929.html Wed, 25 Feb 2009 08:02:34 GMT 林志颖 人生历程 谷歌李开复: 我的传奇人生源于十句箴言 http://princetonboy.ycool.com/post.3143504.html 一个成功的人如何定义成功? 一个成功的人如何从成功中获得启发? 这个命题无疑会让许多人充满了悬念与期待. 2008年11月30日下午, 北京青年报大厦的20层大会议室迎来了北青教育大讲堂活动开办以来最爆满的盛况, 谷歌全球副总裁、大中华区总裁李开复的到来, 让许多人对于成功的定义有了崭新的认识.
对于成功, 不仅仅是对名利的追逐, 不应该完全用世俗的价值观去衡量成功与否, 而是实现自己的价值, 关爱自己身边的人, 给这个世界带来更多的影响力, 用自己的力量去感染周围的磁场. 当你某一天逝去的时候, 你的墓志铭上应该撰写的是对你最公平的评价. 成功的定义应该是多元化的.
在这个下午, 谷歌大中华区总裁李开复用平实而不失幽默的语言, 讲述了自己成长中的很多故事. 和许多人的成长经历相似, 他的成长中也有儿时的淘气顽皮, 学生时代的疑问与困惑, 有获得成功时的泪水与喜悦, 也有经历困难与挫折时的蹉跎与彷徨. 甚至有经历人生最低潮时期的痛苦与煎熬. 但是与众不同的是, 李开复在成功中收获了经验, 在失败中得到了成长. 他把富有传奇的人生经历浓缩成为十句具有启发性的箴言, 在如同与你交谈般的娓娓道来中, 将这种宝贵的人生经验像冬日暖阳一样洒满了整个房间.
 
●成功箴言之一: 自信不失谦虚谦虚不失自信
李开复1961年出生于台湾, 母亲在43岁高龄时生下他前, 被医生数次劝阻. 因为医生透露, 如此高龄的产妇很可能生下白痴. 但是母亲不顾一切劝阻生下了这个幺儿. 这个幺儿在母亲的极度宠爱下自由自在地成长着, 喜欢做很多恶作剧. 把家里所有的钟表调慢一小时以便晚上床睡觉. 把邻居池塘里的水放干以证实邻居池塘里并没有100条鱼. 这一切母亲都只是报以宽容的一笑. 但是母亲不允许孩子傲慢和目中无人.
当5岁的李开复得意洋洋地对邻居阿姨表示“上小学以后就没有见过99分”后. 母亲不允许这样的狂放存在于孩子身上, 有史以来第一次打了开复. 母亲告诉他, “不只要好好学习, 还要改掉骄傲的毛病. 自夸是要不得的. 谦虚是中国人的美德.” 母亲总是不失时机地把做人的道理告诉开复. 这一次强烈的记忆, 使得开复懂得如何在谦虚和自信中保持平衡, 而不会在自卑或自负中跌倒.
 
●成功箴言之二: 天赋就是兴趣兴趣就是天赋
李开复11岁留学美国之后, 一直在美国成长. 1972年, 他进入了美国哥伦比亚大学学习“政治科学”专业. 然而两年的学习让他知道自己的兴趣并非在政治方面. 学习的枯燥经常让他在课堂上昏昏欲睡, 学习成绩也不尽如人意. 但是,他发现他在选修的计算机课上, 有着惊人的天赋. 往往是别人还在苦思冥想如何写出程序时, 他早就把程序写完而无所事事. 后来, 他发现他像发疯一样爱上了这门学科. 因此, 在大学二年级时, 他自己做出了一个惊人的决定, “转系!” 这意味着他将从一个全美排名第3的专业转到一个毫无名气可言的专业. 但是, 他听从了内心的选择, 还是选择了计算机专业. 而这个决定, 改写了他一生的轨迹.
 
●成功箴言之三: 思考比传道重要观点比解惑重要
李开复以哥伦比亚大学计算机专业第一名的成绩毕业以后, 顺利进入匹兹堡的卡内基·梅隆大学就读计算机专业的博士. 在读博士之前, 他的系主任Haberman就告诉他, 读博士的目的, 就是要做出世界上一流的博士论文. 至少在本领域是世界顶尖的. 这句话让李开复十分震撼. 然而, 下面一句话, 让他受益更深, Haberman说, “做出一流的博士论文, 也不是读博士的最终目的. 而是你在读博士的过程中, 获得一种思考的方法, 而这种方法将使你在任何一个领域, 都获得顶尖的成功!” 而李开复的努力证实了这种说法. 李开复关于统计学方法做出的语音识别博士论文至今还是语音识别产品的理论基础. 而李开复也在博士生涯中, 学会了解决问题, 拥有了战胜困难的勇气.
 
●成功箴言之四: 我不同意你但我支持你
李开复在读博士期间选择的研究方向是“语音识别”. 师从博士生导致罗迪. 罗迪教授鼓励李开复用专家统计的方法来研究语音识别, 而李开复在这个领域经过了一番研究后, 发现语音识别用这个方法可以获得特定语者95%的语音识别率. 李开复把整个研究过程写了一篇论文. 一经发表, 得到了很正面的回馈. 但是他最终发现, 专家系统是有严重局限性的, 无法延伸到做不特定语者的语音识别. 他认为有数据的支持的统计模式是唯一的希望. 当他把想法告诉导师, 罗迪告诉他, “我不同意你, 但是我支持你!” 这样的说法让李开复备受感动, 成就了李开复博士论文的成功. 他的论文当年被评为《商业周刊》最杰出创新.
 
●成功箴言之五: 挫折不是惩罚而是学习的机会
李开复在博士生生涯里, 成绩依然优秀. 他用统计学做出的语音识别率大大地提高了而博士论文发表在国际期刊上, 让全美的科技界震惊. 这样一个明星学生可以说在卡内基·梅隆里没有什么忧愁可言. 然而, 一次暑期课程让他经历了不小的挫折. 1983年暑假, 李开复得到了暑期工的工作.
其任务就是教宾夕法尼亚州60个最聪明的高中生计算机课程. 李开复自己对那段时光非常享受, 每天忙碌地备课, 还想出各种教学方法. 但是, 他领取薪水的那一瞬间看到学生的评语, 才知道学生认为, “李老师的教学就像催眠曲!” 这样的评价无疑使得李开复备受打击.
然而, 李开复并没有气馁. 他把失败当成了学习的机会, 因此获得了成功. 他在此后的生涯里, 尤其是回到中国以后, 做了上千场的演讲. 这无疑得益于学生时代的练习.
 
●成功箴言之六: 创新不重要有用的创新才重要
在苹果和SGI李开复度过了八年科学家到产品副总裁的路程. 在这段路程上, 他有许多成功, 例如苹果的QuickTime, 但是在SGI他碰到了巨大的挫折. 他的团队发明的三维浏览器, 在市场上失败, 整个团队和产品被公司廉价卖掉. 这时, 他又发挥了“从挫折中学习”的反省. 他理解了, 仅仅有科学家的“新”、“酷”的创新是不够的. 创新必须是针对用户的, 必须是有用的. 做产品的管理, 必须把用户放在第一位. 李开复1998年夏天回到中国, 在中国开创微软中国研究院. 这时, 他把这个教训带入中国团队.
 
●成功箴言之七: 完美的工作成长兴趣影响力
2000年, 李开复被调回微软总部成为微软全球副总裁. 几年工作后, 他深深地体会了一个完美工作的标准, 那就是自己有浓厚的兴趣, 能有成长的空间, 并具备一定的影响力. 他怀念着在中国研究院的兴趣, 还有在刚调回美国的学习, 但是他期望着有更大的影响力. 当他发现谷歌将开始在中国创建时, 他主动找到了谷歌 CEO施密特, 并表示愿意加入谷歌. 而施密特十分高兴, 在一个月之后就给了李开复OFFER. 李开复说, 当你遇到喜欢的工作机会, 不需要任何的迟疑, 而需要积极主动来争取. 因为这样的机会往往炙手可热, 一秒钟的犹豫你就可能与之失之交臂.
 
●成功箴言之八: 用勇气改变可以改变的事情
2005年, 是李开复的转折年. 他没有想到, 一次普通换工作的经历引发了一次地震. 微软的诉讼使他陷入了人生最低的低谷. 对他的虚假负面报道铺天盖地而来. 但是, 他想到了他一生的座右铭: 用勇气改变可以改变的事情, 用胸怀接受不能改变的事情, 用智慧分辨两者的不同.
于是, 他全力以赴地投入了这场战斗, 不再理会那些不能改变的谣言. 将从微软提取的30万份邮件资料中找寻有利的证据以证明自己的清白. 经过两个月的努力, 法庭同意李开复到谷歌工作. 最后, 当李开复回到媒体面前开始工作时, 他发现, 没有一个记者还提问与诉讼有关的问题, 因为作为官司的胜利者, 媒体不再相信那些谣言.
 
●成功箴言之九: 做最好的领导让员工做有兴趣的事
谷歌公司聚集着世界上最天才的工程师们. 如何管理这些“天才”, 是摆在李开复面前的另一个课题. 李开复非常推崇“放权”式的管理, 他深知在以创意为主要生产力的公司里, 不能严格地恪守那些死板的规定. 他可以让员工自己提出研究的方向. 大家讨论决定. 也可以让员工用20%的时间做自己喜欢的项目. 他甚至可以让员工对公司提出建议. 如果合理就采纳. 谷歌里自由的环境非常有名. 作为管理者, 他主要是在公司战略、每年的目标、合作伙伴、总部沟通上努力, 其他的时间, 他更是一个企业文化的维护者、公司的发言人、员工的教练.
 
●成功箴言之十: 价值不是你拥有多少而是你留下多少
什么是成功? 是否拥有了名利就算成功. 对此, 李开复回答, 你的价值不是你拥有多少, 而是你留下多少. 当他的一个同事赚够了钱而发现失去人生目标时, 才意识到, 人生的价值在于贡献和对他人的影响.
李开复曾经有过一个独特的梦想, 就是在中国创建一所一流的, 有世界影响力的私立大学. 他甚至身体力行地为此多方奔走. 但是最终因为种种原因没有成功. 但是他并没有气馁, 而是用另外的方式实践梦想. 他说: “我不能改变教育, 但是我可以帮助学生.” 他给中国的大学生写信, 写书, 办了“我学网”, 每年面对十万学生做演讲. 在帮助学生的过程中, 李开复看到中国大学生的成长. 他说, 他曾经想过自己的墓志铭应该有科学家或者企业家的注脚. 但是, 他说他现在已经没有这种想法, 如果他的墓志铭上有热心教育者的字样, 他会感觉到内心的温暖.
... ]]> http://princetonboy.ycool.com/post.3143504.html Wed, 21 Jan 2009 04:01:49 GMT 成功 好久没来,说两句 http://princetonboy.ycool.com/post.3115032.html        时间飞快,转眼2008年要即将远去,回顾与思考之余,似乎更多的是无奈.
       辛苦但不是很努力的工作了9个月,让我大受打击的是第一个工作之年却没有年末奖金,公司对内声明现在拥有没有内债和外债的3亿美金的现金作为过冬的储备,却不给我们发奖金,于情于理都说不过去,这绝对不是一个人性化的企业. 要知道我们平时的工作时间基本上是早上九点半到晚上八点,虽然公司规定下班时间是下午五点半,但是我们ONS研发部门的人基本上每晚都是晚上八点以后才离开公司的,可以说基本上把我们的美好时间都献给了它,可是到头来呢,连年末奖金都没有,虽然知道这次经济危机的严重性以至于很多的公司在裁员或者是降薪,有的甚至倒闭. 但是人都这样子的,就像自己付出了很多汗水与心血,但是最后却没有任何回报,内心总有不少的失落与无奈.
       也因为如此,自己做了换工作的打算,当然还只是计划,还是没有做详细布置的计划. 这几个月真的几乎把所有的时间都献给了工作,真的有点伤感. 伤感是因为我心疼自己那宝贵的时间和自己的精力.
       昨天圣诞节和宝宝一起在家里度过,顺便去修了一下态势台式电脑(都坏了几个月了),是电源坏了,于是买了一个新的电源,顺便给自己的笔记本买了个小鼠标(我的笔记本都n个月没有用鼠标了) 一共花了200块大洋! 然后去浮力森林拿蛋糕(公司发的蛋糕券). 宝宝是个特别容易满足的小女孩,拿了两个小蛋糕就很开心,说以后想吃再来领,看着她我的感觉比蛋糕还甜,很多时候我都能在她身上得到安慰,老天能让我碰到这样的知己我真的很感谢了.
       今天宝宝要上班了,而我申请了调修连起来放假四天,这几天准备一下自己的简历. 宝宝在阿里巴巴辛苦的坚持了6个月终于转正加薪了,转正后的工资还挺诱人的,都快赶上我了呢! 我今天起来后就一直呆在电脑前到现在,都已经习惯了这样的生活方式了,因为工作也是这样一天到晚跟着电脑面对面. 听听音乐,在TopCoder上看看题目做做题目,没有压力这就是我的喜欢的生活,但是现实不能总这样生活,所以只好趁自己一个人的时候偷偷懒,享受享受这舒服的生活! 不过舒服的生活总是太短暂.
       马上就要进入2009年,自己又长一岁,感觉时间拼命抓都抓不住,我还来不及调整自己,一切就都扑面而来. 最近在看曾经是新东方老师的张扬的书《我的哈佛日记》,知道了还有人的学习和生活方式是这样的,这也是我曾经的梦想,当然也是我一直的梦想,因为我并没有放弃追求. 告诉自己: 伤心的时候微笑,高兴的时候大笑,乐观看待一切成败是最好的心态. 人有完整的心态才有完整的人生.
       人生就像一个魔方,应该不停的思考,旋转和寻找. 其实很多时候人的幸福和快乐是自己把握的. 乐观的心态,自得其乐,随遇而安,平和的心态,这样就会发现其实声明很短暂,但是快乐却可以很稳定. 见到的世界越大,就越能看到自己明显的改变. 我告诉自己,在未来的一年里,不要放弃自己的梦,朝着它乐观的一路追寻,就对了!
... ]]> http://princetonboy.ycool.com/post.3115032.html Fri, 26 Dec 2008 09:12:13 GMT 生活 感悟 SRM426 Division II - ShufflingMachine http://princetonboy.ycool.com/post.3100814.html 1. Problem Statement for ShufflingMachine
Problem Statement
A card shuffling machine is a device designed to randomize the order of a deck of cards. A particularly poor (but unfortunately relatively common) design of machine works as follows: an integer N is selected uniformly at random between 1 and maxShuffles, inclusive, and a series of N exactly similar deterministic shuffles are performed. A deterministic shuffle is a fixed permutation of the cards. The randomness of the resulting ordering is clearly therefore only dependent on the number of shuffles chosen. After the deck has been shuffled N times, the cards are distributed to the players.
A particularly dishonest player has decided that he wishes to cheat. He has identified K cards in the deck that he wants to receive when the cards are distributed. He has managed to figure out both the fixed shuffle that the machine uses and also the maximum number of shuffles chosen. The fixed shuffle is given in a vector <int> shuffle, in which element i gives the position after the shuffle of the card that was initially in position i (both 0-based). The positions in the deck of the cards the player will receive after they have been shuffled are given in cardsReceived (0-based). Before the cards are shuffled, the player can order them in any way he wishes. Determine the initial ordering that will maximize the expected number of the K desired cards that he will receive and return this expected number.
Definition
Class: ShufflingMachine
Method: stackDeck
Parameters: vector <int>, int, vector <int>, int
Returns: double
Method signature: double stackDeck(vector <int> shuffle, int maxShuffles, vector <int> cardsReceived, int K)
(be sure your method is public)
Notes
- Your return value must be accurate to an absolute or relative tolerance of 1e-9.
Constraints
- shuffle will contain between 1 and 50 elements, inclusive.
- shuffle will be a permutation of the numbers between 0 and M-1, inclusive, where M is the number of elements in shuffle.
- maxShuffles will be between 1 and 100, inclusive.
- cardsReceived will contain between 1 and M elements, inclusive.
- Each element of cardsReceived will be between 0 and M-1.
- The elements of cardsReceived will be distinct.
- K will be between 1 and M, inclusive.
Examples
0)
{1,0}
3
{0}
1
Returns: 0.6666666666666666
This deck contains only 2 cards and they swap positions after each shuffle. The cheating player receives first card in the deck after the shuffling is completed and he wants to receive 1 of the cards in the deck. If the deck is shuffled 1 or 3 times, he will receive the card that was initially in position 1. If the deck is shuffled 2 times, he will receive the card in position 0. It is therefore optimal to put the card that he wants in position 1 and he will receive it 2 times out of 3.
1)
         {1,2,0}
         5
         {0}
         2
         Returns: 0.8
If he puts the cards he wants in positions 1 and 2, he will receive one of them 4 times out of 5.
2)
         {1,2,0,4,3}
         7
         {0,3}
         2
         Returns: 1.0
         If he puts the cards in positions 3 and 4, he will receive exactly one of them, regardless of how many shuffles are chosen.
3)
         {0,4,3,5,2,6,1}
         19
         {1,3,5}
         2
         Returns: 1.0526315789473684
4)
         {3,4,7,2,8,5,6,1,0,9}
         47
         {6,3,5,2,8,7,4}
         8
         Returns: 6.297872340425532
 
This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2003, TopCoder, Inc. All rights reserved.
 
2. Problem Analysis for ShufflingMachine
         First of all, we should understand that what results does the problem wants us to make out. We see the last sentence: “Determine the initial ordering that will maximize the expected number of the K desired cards that he will receive and return this expected number.” So, if I have a desired card and a position in the deck of the cards that I will receive(called cardsReceived position.) after they have been shuffled, when I know the fixed shuffle that the machine uses and the number of shuffles chosen, then I can figure out which position(s) I should put the desired card in initial ordering to receive it. Then, if I only know the fixed shuffle that the machine uses and the max shuffles number maxShuffles, it is we can choose the number of shuffles between 1 and maxShuffles, to maximize the expected number of the desired card that I will receive, I will put the desired card in some position in initial ordering which it will be shuffled to the receive position as far as possible after all of maxShuffles times shuffles. Such as example 0 :
       
                                                              Graph one
Pay attention that if there are more than one desired card, then you only need to receive one of them on the round. So, if there are two desired cards like example 1, you only need to select two cards’ positions with the most times appearing on the cardReceived position. In example 1, the two cards are B and C in the following graph.
       
                                                                     Graph two
If there are more than one cardsReceived position, then you only need to select K cards’ positions with the most times appearing on these cardReceived positions. Such as example 2 in graph three:
        
                                                                      Graph three
From the graph above, we can see that we select D and E cards’ positions to put the desired K cards. Because the two cards appears on the cardsReceived positions most frequently with totally 7 times. Exactly, we can also select C and E cards’ positions.
 
Now, we know how to make out the expected number! J
 
3. Source Code for ShufflingMachine
#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std ;
 
class ShufflingMachine
{
public:
         double stackDeck(vector <int> shuffle, int maxShuffles, vector <int> cardsReceived, int K)
         {
                   int i , j , count = 0 ;
                   int cards = shuffle.size() , cardsR = cardsReceived.size() ;
                   vector <int> card1 ;
                   vector <int> card2(cards,0) , exsit(cards,0) ;
 
                   for (i = 0 ; i < cards ; i ++)
                            card1.push_back(i) ;
 
                   for (i = 0 ; i < maxShuffles ; i ++)
                   {
                            for (j = 0 ; j < cards ; j ++)
                                     card2[shuffle[j]] = card1[j] ;
                            card1 = card2 ;
 
                            for (j = 0 ; j < cardsR ; j ++)
                                     exsit[card1[cardsReceived[j]]] ++ ;
                   }
 
                   sort(exsit.begin(),exsit.end()) ;
 
                   for (i = 0 ; i < K ; i ++)
                            count += exsit[cards-i-1] ;
 
                   return 1.0*count / maxShuffles ;
         }
protected:
private:
};
... ]]> http://princetonboy.ycool.com/post.3100814.html Mon, 01 Dec 2008 05:12:15 GMT search , simple maths SRM426 Division II - KnockoutTourney http://princetonboy.ycool.com/post.3100811.html 1. Problem Statement for KnockoutTourney
Problem Statement
You have just entered a knockout tournament with N competitors. The tournament is structured as follows: at the start, the competitors are written down in a list. Adjacent competitors in the list are then paired off, starting from the first competitor on the list, and each pair plays a match (competitor 1 plays against 2, 3 plays against 4, etc.). The losers of each match are eliminated and their names are crossed off the list, while the winners progress to the next round. If there are an odd number of competitors in a round, then the last competitor in the list advances to the next round automatically, without having to play a match. This process then repeats with the new list of competitors, until only a single competitor remains, who is declared the winner. Note that the ordering of the competitors is preserved between rounds.
Your arch-rival has also entered the tournament and you want to know when you might end up playing against him. Your position in the list for the first round is you and your rival's position is rival (both indexed from 1). Assuming that both you and your rival win all the matches before you play each other, return the number of the round in which you will meet (counting the rounds from 1).
Definition
Class:KnockoutTourney
Method: meetRival
Parameters:int, int, int
Returns:int
Method signature:int meetRival(int N, int you, int rival)
(be sure your method is public)
Constraints
-N will be between 2 and 100000, inclusive.
-you and rival will each be between 1 and N, inclusive.
-you and rival will be distinct.
Examples
0)
16
1
2
Returns: 1
This is a 4 round tournament, with 16 players, so every player plays a match in every round. You are paired with your rival in the first round.
1)
         16
8
9
         Returns: 4
Despite being adjacent in the list, you are not paired with your rival until the final round.
2)
         1000
20
31
Returns: 4
3)
65536
1000
35000
Returns: 16
4)
60000
101
891
Returns: 10
 
This problem statement is the exclusive and proprietary property of TopCoder, Inc. Any unauthorized use or reproduction of this information without the prior written consent of TopCoder, Inc. is strictly prohibited. (c)2006, TopCoder, Inc. All rights reserved.
 
2. Problem Analysis for KnockoutTourney
From the describing of the problem, we know that the process of the competition is as fallows:
Step one:
        
Graph one
Step two:
         The first round, the competition is as the graph above. Then, the second round, the winners of the first round become the competitors of the second round, and as the first round, adjacent competitors in the list are then paired off, starting from the first competitor on the list, and each pair plays a match (competitor 1 plays against 2, 3 plays against 4, etc.)
 
… and so go on.
 
         The key of this problem is that you should note that the ordering of the competitors is preserved between rounds. Without this condition, we can’t compute the result.
         We find that two competitors are adjacent when they play against each other, furthermore, the index of the bigger one in the list of the two competitors is an even number. So, if you and your arch-rival play each other in some round, firstly, you are adjacent each other, secondly, the bigger index of you in the list is an even number. Now you should understand if you+1 is equal to rival and rival is an even number, or rival+1 is equal to you and you is an even number, then you will meet your arch-rival.
 
3. Source Code for KnockoutTourney
#include <iostream>
 
using namespace std ;
 
class KnockoutTourney
{
public:
         int meetRival(int N, int you, int rival)
         {
                   int round = 0 ;
                   while (true)
                   {
                            if ( (you+1 == rival && 0 == rival%2) ||
                                     (rival+1 == you && 0 == you%2) )
                            {
                                     return ++ round ;
                            }
                            else
                            {
                                     you = (you+1) / 2 ;
                                     rival = (rival+1) / 2 ;
                                     round ++ ;
                            }
                   }
                   return 0 ;
         }
protected:
private:
};
... ]]> http://princetonboy.ycool.com/post.3100811.html Mon, 01 Dec 2008 04:12:00 GMT simple maths UOML打破微软垄断 成中国软件业首个国际标准 http://princetonboy.ycool.com/post.3090314.html 长久以来被微软等跨国公司所垄断的文档信息产业,即将被中国人自己制定的软件标准所打破. 昨日,中国电子工业标准化技术协会(下称“中电标协”)宣布,由电子文档读写接口标准UOML已经被结构化信息标准促进组织OASIS批准为国际标准,成为中国软件行业第一个国际标准.
 
51成员赞成
UOML是非结构化操作置标语言的缩写,它定义了电子文档的读写接口标准,即让不同格式的文档能够实现互相读写. 包括微软的Word、Excel等文档、金山的文档、Adobe公司的PDF文档,以及各种各样的网上电子书格式.
中国工程院院士倪光南认为,UOML标准对中国软件产业在文档领域占据一定话语权起着重要作用.
据中电标协负责人表示,电子文档无法互联互通的问题已经成为一个世界性的问题,目前世界上有1万多种文档格式,常用文档格式有300多种,彼此的兼容性很差,不同电子文档之间的数据无法交换. 当文档编辑完成,进入流转和分发环节时,不同格式的文档相互无法打开浏览.
此次投票赞成UOML成为国际标准的有国际上51家企业、用户与学术机构,如谷歌、惠普、富士通等.
 
产业化之路
随着UOML标准的确立,中国软件企业将在年产值达数百亿美元的文档产业中占领一个重要制高点. 书生、汉王、红旗2000、紫光等公司支持UOML标准的软件产品及应用解决方案已经推出,并已开始在国内重点行业试点应用. 工业和信息化部科技司相关负责人表示,工业和信息化部将在政府采购及其他公共财政资金采购中,制订优先采购符合UOML标准的产品的政策.
中电标协方面表示,UOML下一步除了加快产业化外,正准备在工业和信息化部科技司的领导下,将标准提交给另一标准化组织ISO,申请成为ISO国际标准.
 
打破微软垄断
不过,微软所推广的MS Office软件在全球文档格式领域占强势地位,所以目前微软却对中国人制定的软件标准---UOML深怀“敌意”.
中电标协文档库技术标准工作委员会(下称“文标委”)主任王东临透露,微软也是OASIS成员之一,但是由于UOML标准能够打破微软的垄断,所以微软并不赞成UOML标准成为国际标准,投票中微软投了“弃权票”.
文档是使用最普遍的信息资源,因而文档标准是信息领域的一个关键性标准. 自上世纪90年代以来,微软MS Office软件垄断了市场,由于缺乏强制性的标准,用户只得依赖微软的软件,而并没有真正掌握文档信息的控制权.
事实上,微软的Word文件,用微软自己的Excel都不能打开,导致文档信息被特定软件所垄断. 这就产生了很多严重的后果,例如用户被微软等垄断厂商锁定,市场缺乏自由竞争,文档资源难以被重复利用等.
倪光南认为,目前的文档格式标准是微软主导的,由于该标准不开放,对于政府部门来说,在使用时还会涉及到信息安全问题. 所以,目前的UOML标准能够打破垄断,保证中国对信息资源的控制权.
王东临介绍到,虽然微软目前仍然不支持UOML标准,不过微软公司的MS Office文档可以转化为支持UOML标准的文档. 不论哪种软件,只要支持UOML标准,就能够打开任何一个UOML文档,解决目前电子文档不能实现互联互通的尴尬现状.
... ]]> http://princetonboy.ycool.com/post.3090314.html Tue, 11 Nov 2008 12:11:07 GMT uoml SRM423 Division II http://princetonboy.ycool.com/post.3084259.html #include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
 
using namespace std ;
 
// 500
 
const int MAXLEN = 51 ;
#define min(a,b) (((a) < (b)) ? (a) : (b))
 
class TheTower
{
public:
       vector <int> count(vector <int> x, vector <int> y)
       {
              int i , j ;
              int val[MAXLEN] ;
              vector <int> rx , ry ;
 
              int m = x.size() ;
              vector <int> res(m,INT_MAX) ;
              memset(val,0,sizeof(val)) ;
              // 所有可能的摆放位置
              for (i = 0 ; i < m ; i ++)
                     for (j = 0 ; j < m ; j ++)
                     {
                            rx.push_back(x[i]) ;
                            ry.push_back(y[j]) ;
                     }
 
              int n = rx.size() ;
              for (i = 0 ; i < n ; i ++)
              {
                     // 对于每一个摆放位置,求出1-m个checker重叠的距离和
                     // Begin
                     for (j = 0 ; j < m ; j ++)
                            val[j] = abs(rx[i]-x[j]) + abs(ry[i]-y[j]) ;
                     sort(val,val+m) ;
                     for (j = 1 ; j < m ; j ++)
                            val[j] += val[j-1] ;
                     // End
                     // 与当前已经求出的最小距离比较,求出所有摆放位置中的最小距离
                     for (j = 0 ; j < m ; j ++)
                            res[j] = min(res[j],val[j]) ;
              }
 
              return res ;
       }
};
 
// 250
 
class TheSimpleGame
{
public:
       int count(int n, vector <int> x, vector <int> y)
       {
              int cnt = 0 ;
              int m = x.size() ;
              // 把板分成"田"字格,该checker在哪个格子中,就向相应的角落移动
              for (int i = 0 ; i < m ; i ++)
              {
                     int X = n / x[i] ;
                     int Y = n / y[i] ;
                     if (X >= 2 && Y >= 2 )
                     {
                            cnt += (x[i] - 1) ;
                            cnt += (y[i] - 1) ;
                     }
                     else if (X >= 2 && Y >= 1)
                     {
                            cnt += (x[i] - 1) ;
                            cnt += (n - y[i]) ;
                     }
                     else if (X >= 1 && Y >= 2)
                     {
                            cnt += (n - x[i]) ;
                            cnt += (y[i] - 1) ;
                     }
                     else if (X >= 1 && Y >= 1)
                     {
                            cnt += (n - x[i]) ;
                            cnt += (n - y[i]) ;
                     }
              }
              return cnt ;
       }
};
... ]]> http://princetonboy.ycool.com/post.3084259.html Fri, 31 Oct 2008 11:10:05 GMT division ii srm423 砝码称重 http://princetonboy.ycool.com/post.3078361.html 一.   问题描述
设有1g, 2g, 3g, 5g, 10g, 20g的砝码各若干枚(其总重小于等于1000),要求:
输入:
a1    a2    a3    a4    a5    a6 (表示1g砝码有a1个,2g砝码有a2个,…,20g砝码有a6个)
输出:
       Total=N (N表示用这些砝码能称出的不同重量的个数,但不包括一个砝码也不用的情况.)
输入样例:      1     1     0     0     0     0
输出样例:      Total=3, 表示可以称出1g, 2g, 3g三种不同的重量.
 
二.   问题分析
设
const int TOLVAL = 1000 ; // 砝码的最大总重量
const int num[] = {1,2,3,5,10,20} ;  // 砝码的重量序列
int a[6] ;  // 6种砝码的个数
bool visited[TOLVAL+1] ; // 重量的访问标志序列,防止重复记录
int no[TOLVAL+1] ; // no[0] – 不同的重量数; no[j] – 第j种重量(1≤j≤第i阶段的no[0]值)
int i, j, k, total ; // total – 目前称出的重量
 
我们按照第1种砝码,第2种砝码,…,第6种砝码的顺序分析. 在分析第i种砝码的放置方案时,依次在当前阶段i下的现有不同重量的基础上,放1块, 2块,…, a[i]块,产生新的不同重量,和阶段i下的现有重量一并作为下一个阶段i+1的现有不同重量.
no[no[0]+1] = total | total = cur + k*num[i] , visited[total] = false, cur=第i阶段的no[0]值,1≤i≤no[0], 1≤j≤cur, 1≤k≤a[i]
阶段i : 分析第i种砝码(1≤i≤6) ;
状态j : 枚举现有的不同重量(1≤j≤第i阶段的no[0]值) ;
决策k : 在现有重量的基础上放k块第i种砝码,产生重量cur + k*num[i]( 1≤k≤a[i]) ;
 
三.   程序源代码
#include <iostream>
#include <vector>
#include <string>
 
using namespace std;
 
const int TOLVAL = 1000 ; // 砝码的最大总重量
const int num[] = {1,2,3,5,10,20} ; // 砝码的重量序列
int a[6] ;  // 6种砝码的个数
bool visited[TOLVAL+1] ; // 重量的访问标志序列,防止重复记录
int no[TOLVAL+1] ; // no[0] - 不同的重量数; no[j] - 第j种重量(1≤j≤第i阶段的no[0]值)
int i, j, k, total ;  // total - 目前称出的重量
 
 
int main()
{
       int i , j ;
       while (true)
       {
              memset(visited,false,sizeof(visited)) ;
              for(i = 0 ; i < 6 ; i ++) // 输入6种砝码的个数
                     cin >> a[i] ;
              no[0] = 1 , no[1] = 0 ; // 产生第1种重量0
              for (i = 0 ; i < 6 ; i ++) // 阶段: 分析第i种砝码
              {
                     int cur = no[0] ;
                     for (j = 1 ; j <= cur ; j ++)  // 状态: 枚举当前阶段i下的所有不同重量
                            for (k = 1 ; k <= a[i] ; k ++) // 决策: 在现有重量的基础上放k块第i种砝码
                            {
                                   total = no[j] + k*num[i] ;  // 产生的重量
                                   if (!visited[total]) // 若该重量未产生过,则设访问标志
                                   {
                                          visited[total] = true ;
                                          no[0] ++ ;  // 新重量进入no序列
                                          no[no[0]] = total ;
                                   }
                            }
              }
              cout << no[0]-1 << endl ;  // 输出不同重量的个数
       }
       return 0 ;
}
... ]]> http://princetonboy.ycool.com/post.3078361.html Wed, 22 Oct 2008 04:10:24 GMT dp 砝码称重 SRM422 Division II http://princetonboy.ycool.com/post.3078058.html #include <iostream>
#include <vector>
#include <string>
#include <cmath>
using namespace std ;
 
// 1000
 
class BirthdayCake
{
public:
       int howManyFriends(vector <string> availableFruits, vector <string> friendsDislikings, int K)
       {
             
       }
};
 
// 500
// simple math : Combinatorics + Probability
 
const int M = 18 ;
const int F = 100 ;
const int m[] = {2,3,5,7,11,13,17} ;
const int c[] = {153,816,8568,31824,31824,8568,18} ;
long double ra[7] ,rb[7] ;
 
class PrimeSoccer
{
public:
       double getProbability(int skillOfTeamA, int skillOfTeamB)
       {
              int i , j ;
              long double RA = 0.0 , RB = 0.0 , RC = 0.0 ;
              for (i = 0 ; i < 7 ; i ++)
              {
                     ra[i] = c[i]*pow((double)(skillOfTeamA),(double)(m[i]))*pow((double)((F-skillOfTeamA)),(double)(M-m[i])) ;
                     RA += ra[i] ;
              }
              for (i = 0 ; i < 7 ; i ++)
              {
                     rb[i] = c[i]*pow((double)(skillOfTeamB),(double)(m[i]))*pow((double)((F-skillOfTeamB)),(double)(M-m[i])) ;
                     RB += rb[i] ;
              }
              for (i = 0 ; i < 7 ; i ++)
              {
                     for (j = 0 ; j < 7 ; j ++)
                     {
                            RC += ra[i]*rb[j] ;
                     }
              }
 
              return ( (RA + RB)/pow((double)(F),(double)(18)) - RC/pow((double)(F),(double)(36)) ) ;
       }
};
 
// 250
 
class MultiNumber
{
public:
       string sovle(int n)
       {
              string s = "" ;
 
              while (n > 0)
              {
                     int t = n % 10 ;
                     n /= 10 ;
                     s += (t+'0') ;
              }
              reverse(s.begin(),s.end()) ;
              return s ;
       }
       string check(int number)
       {
              int i , j ;
              string str , res ;
              if (number < 10) return "NO" ;
              str = sovle(number) ;
              for (i = 0 ; i < str.size()-1 ; i ++)
              {
                     int t = 1 , p = 1 ;
                     for (j = 0 ; j <= i ; j ++)
                            t *= (str[j]-'0') ;
                     for ( ; j < str.size() ; j ++)
                            p *= (str[j]-'0') ;
                     if (t == p) res = "YES" ;
              }
              if (res == "") return "NO" ;
              else return "YES" ;
       }
};
... ]]> http://princetonboy.ycool.com/post.3078058.html Tue, 21 Oct 2008 15:10:23 GMT division ii srm422 玩扑克牌与编程 http://princetonboy.ycool.com/post.3077696.html (转载)我以前不是做软件开发的. 在加入ThoughtWorks两年之前,我主要靠玩扑克为生. 当然,如果你曾跟我打听过我前臂上的纹身,那你肯定已然听过我的故事了. 要是还没有,等下次我们一起喝一杯时,我可以讲给你听.
 
学习
我学习打扑克和学习软件开发的方式是一样的: 尽可能多读书. 我用两年的时间,读完了所能找到的每一本有关扑克的书. 最后竟至39本之多. 编程亦如是. 此刻,我面前仍然摆着接下来要读的5本书; 而在过去三年ThoughtWorks的工作中,我翻烂的书亦不在少数.
我认为,无论编程还是玩牌,阅读书籍、博客与杂志都是要想有所成就的必备条件; 而若要以二者为谋生之业,仅靠读书却是远远不够的. 也许你可以把书本上的一切知识都装入脑中,但知道在何时应用何种规则,这才是真正高手的标志.
诚然,开卷有益. 但总要走过万里路,方能对应用特定技术的具体环境烂熟于心. 书本不可能把所有情况都囊括一空,只有通过亲身体会得来的经验,才能让你在某些状况下为自己或是雇主做出快速而正确的决策,而这些决策可能价值几千乃至数百万美元. 经验之宝贵,世间无物可代.
 
艺术的巅峰
你可以设计出击败普通扑克玩家的计算机程序. 遵守一些基本规则,自然就可获胜. 但迄今为止,还没有任何程序可以击败最好的扑克玩家. 因为扑克技能达到巅峰时,也就成了一门艺术. 软件开发亦如是. 要想成为一个还行的开发者,只要遵循一系列最佳实践即可. 如果按照经典参考指南一类的书籍行事,开发出还不错的应用程序应该不成问题,而且效果会胜过其他最常见的做法. 有了这么多失败的项目作为前车之鉴,我相信,还不错的应用就足以令大多数管理层甘心掏腰包了.
当然,有些经理有更高的标准. 在银行、创业公司、医疗系统等领域,标准则更为严苛. “还不错”自是远远不够. 那些经理会很乐意为最佳选择买单,他们期待的是远超常人的技能. 但问题在于,专家级程序员的技能与普通程序员不同. 普通程序员知道做事的方式; 专家知道做事的目的.普通程序员会僵化跟随模式书籍中的指示,就如遵守参考指南一般; 专家则明白对模式的创新可能会带来指数级的性能改善.
他们看到的绝非同一个世界,所以普通程序员很难跟专家对面交流. 做艺术评论家易,做优秀的艺术评论家难.
 
决策技能
在扑克和编程中有一条绝对真理: 几乎没人能像他自我感觉的那么良好. 有自知之明是不错的开始,但人们依然很难知道自己与专家之间的差距. 程序员接触专家的机会并不多,也就无法公正评判自己的技能. 在牌桌上,每个人都是为了锦标而来,可大多数人都会过高评价自己的牌技,这总是让我惊讶不已.
程序员之间亦是如此,而且大多数人可以获得的信息更少得可怜. 一个从不参加任何大会的技术领导人,只能跟自己的团队成员一比高下. 当然,他可能已经很优秀了,否则也不会成为技术领导. 但如果与整个行业中最出类拔萃的人相比,他又处于什么位置? 如果觉得在自己的圈子里已经一览众山小了,那碰到不同意见时,他又会作何反应? 有些人会视之为学习的契机并为此感到兴奋,但绝大多数都会对不同意见嗤之以鼻.
 
团队协作
乍看上去,扑克是一种彼此对抗的游戏. 但事实很少如是. 即使在赌注最小的牌桌上,通常也至少会有几个人常打交道. 他们不会达成条件一致对付牌桌上的其他人---他们也不必如此. 大家都明白一条道理: 你不是要去跟牌玩得好的人对着干,赢他们的钱,而是要从水平低的人身上赚钱. 专业牌手甚至会像一个团队一样协同工作. 有些人彼此利益相关,故而一人得利则众人均有收益. 他们不仅互相了解,而且认识很多人. 如果出现一局精彩牌局,楼层经理会跟他们打招呼; 侍者会为他们的对手调制酒精度高的饮品; 和手(即发牌者)会故意“犯错”以影响某人心情(很少有人在心情不好的时候能够打好牌). 每个人都在协同工作,确保大家都能挣到钱.
颇为有趣的是,程序员的情况也与之相似. 很多人都坐在格子里,完全依赖自己解决问题.他们往往工作在代码个人独有制模式之下. 我曾亲眼目睹,在这种程序员交付的应用中,集成问题一直都是大家的心病. 而更为不幸的是,集成之痛还只是最小的问题. 假设IT部门把业务需求锁定为500页的需求文档. 如果公司决定改变业务方向,随之而来的系统变更需求将令人痛不欲生. 数以百万计的金钱付诸东流,因为程序员开发的特性已不再具备业务价值,而IT部门还没有找到更好的方式来应对业务变化.
当然,情况并非总是如此. 专家懂得协作. 他们会跟其他专家协作,但也不排斥与经理、客户、业务部门、分析师、质保人员,以及所有可以为成功贡献力量的人协作. 他们胸怀大局:只有协作,才能让每个人有所收获.
 
度量
雄心勃勃的牌手常常讨论他们赢了多少手牌,又输了多少手. 他们讨论最多的还是本该赢但却输掉的那几手牌. 有时人们会犯错误输钱,但他们一般都不会记得这几手是怎么输掉的. 相反的是,如果有些牌局只是因为手气不好而输掉,他们就会记得那一局中的每一处细节,他们还会在故事中透露对手必然获胜的几率,来证明自己根本没有胜出的机会. 真正的牌手知道他们输掉过多少手牌,以及失败的大概几率. 他们懂得度量. 而且专业牌手会专注于重要的度量标准. 你赢了多少手,输了多少手,这无关紧要; 重要的是你赢了多少钱,输了多少钱. 而且,为你的狗屎运(译者注: bad beat,即开局时输家比赢家牌好,赢的几率更大,但关键时刻赢家却来了更好的牌. 碰到狗屎运---take a bad beat---用来形容输家,来了狗屎运---lay a bad beat---用来形容赢家)苦恼实际上等于替你对手的牌运犯愁. 既然你的收入来自于对手的错误,那你就是在抱怨为什么对手把钱给了你.
有度量标准是好事,不过专业人士懂得哪些标准重要,哪些只会分散注意力,哪些介于二者之间.
软件开发也有很多度量标准,而且有很多标准身上的光环已经远远超出了它们所应有的范围. 例如,知道代码行数几乎不能带来任何价值. 复杂应用需要相当多的代码,但这个“相当”到底是多少? 它得依赖于语言、工具及其他因素.
修复的bug数量也是个很有趣的话题,只是略逊于前一个. 为什么人们会在乎修复了多少个bug? Bug数量也许有其价值,但是修复的bug数目并不能为我们带来多少有用信息.
特性完成率是我自己最喜欢把玩的一个标准. 除非我们使用特性来评估工作量,否则知道完成了多少特性又有何用? 而且,如果已经对工作量做出了评估,那为什么不把剩余工作与已完成工作相比较,从而得到工作进度呢? 我很难从特性完成率中看到价值所在.
代码覆盖率让我想起了记录狗屎运. 这项度量是有意义的,但很多人都没抓住重点. 代码覆盖率低意味着可能有问题存在,但是代码覆盖率高只能表示你有一个很大的代码覆盖率数值. 高代码覆盖率与高质量之间没有必然联系.
 
注意人,而不是逻辑
如果看过有玩牌镜头出现的电影,你大概听过这样一句话: 你不是在与扑克玩,而是与人玩. 此言极是. 牌手无疑都是心理学家. 有时你确实需要某些牌,但拿一手好牌只是赚钱的一部分而已. 一旦有了好牌,你就需要知道怎样利用好它们. 你是应该加注,还是先让牌然后加注,还是彻底让牌,还是跟进? 这些做法依赖于很多因素,但关键还是要了解牌桌上的对手. 当你得到一手好牌,首要目标就是尽可能多地从对手那里赢钱,而达到这种目的的唯一方式则是想办法让对手给你更多的钱. 了解逻辑可以帮助你赢得几手牌,了解人则可以帮助你赢钱.
在交付软件时,人处于同样重要的地位. 如果软件只是让一切工作起来,那只要把它变成自动化的工作,事情就容易得多了. 但软件却远非功能组合这么简单. 在一场高尔夫球比赛中,人们会卖出软件包; 在全家到迪斯尼免费旅游时,人们会签下软件服务合同; 为了避免法律纠纷,人们会履行合同去构建已经毫无用处的软件; 为了超越竞争对手,人们会使用软件来加快业务响应速度.
人们使用软件、开发软件、维护软件,或是在某种程度上依赖软件. 软件开发与这个世界有着千丝万缕的联系,要把洋洋洒洒的变量组合成简单方程,生产出高质量的软件,又与登天何异? 但是,软件开发高手需要考虑每个人引入的所有已知与未知的变量,做出他们力所能及的推测. 知道应该做什么会让你受益,而知道必须做什么所带来的价值却是难以衡量. 了解逻辑可以帮助你交付应用,了解人则可以帮助你交付价值.
 
在残缺的信息下工作
有关这点,刚开始打牌的人处理的非常好: 打好每一手牌,老老实实押注,从不虚张声势.这便是了,新手就应该只做该做的事情,除非你的钱多得没地方花了. 难点在于如何从初学者的水平提升. 大量信息霎那间纷至沓来,你需要注意牌桌上每个人的每一处细节: 他们怎样交流,你从前跟他们每个人打过什么交道,他们所钟爱的玩牌方式,谁在赢,谁在输,凡此种种不一而足. 而且,你也不可能知道对手手里的牌是什么,下一张牌又是什么. 你所拥有的信息已超出所能处理的极限,而且这远非全部.
编程亦如是. 领域专家无所不知,但把一切都向你倾囊相授却毫无意义. 何况,你也不一定需要所有的领域知识. 你需要熟悉团队,但同事总有些事情是你永远无法知晓,或者不能完全理解的. 不过,编程高手能够把必要的领域知识融会贯通,掌握团队的动态,并始终提供技术上的真知灼见. 他们知道他们永远无法成为百晓生,他们知道什么事情值得思考,哪些应该置之不理.纵使面前汹涌澎湃的信息仍是残缺不全,他们也总能做出正确的决定.
 
即时反馈
普通牌手在反馈信息少的游戏中表现最好. 因为牌手是根据信息而赢钱的. 在5张牌梭哈中只有一轮押注的机会. 各位玩家只有一次机会来分析你给出的信息,而你也只有一次机会犯错. 专家级牌手更喜欢多轮的游戏. 游戏中的回合数越多,他们就有越多机会从低水平的对手身上捞到好处. 他们喜欢即时反馈,并根据反馈做出调整. 在有多个回合的游戏中,每一个回合都可以得到反馈,专业玩家就会根据当前局势调整打法.
编程高手同样喜欢即时反馈. 从业务人员即时反馈回来的信息,可以避免你在构建业务应用时走上弯路. 从另一个程序员即时反馈回来的信息,可以在软件产品化之前发现bug. 持续集成服务器可以提供即时的集成反馈,从而避免集成之痛. 喜欢敏捷的人能马上说出迭代是一个有着显著成效的实践,因为它可以让程序员和业务人员得到即时反馈. 不过,作为一个编程高手,纵使他不喜欢敏捷,他也能够意识到即时反馈的价值; 即使在非敏捷的环境中,他也会争取得到更多的反馈,从而避免浪费时间精力. 即时反馈可以让你了解前行的方向正确与否,每一个专家都会珍视这些信息.
 
上下文为王
无论扑克还是编程,没有绝对正确或是绝对错误的选择. 如果你有一对K,那么在翻牌之前你该不跟么? 也许吧. 这要看你是在打比赛还是赌钱、有上限还是没上限、你坐在哪个位置上、你是否已经不跟过一次还是已经封顶了等等. 我在扑克中学到了一点,那就是在给出答案之前,一定要综合考虑所有的因素.
在编程中沉浸的时间愈久,同样的体会在我心里就愈加深刻. Java在有些时候是不错的选择,但它并非万能. 所有的编程语言均如此. 工具亦然. Hibernate很不错,但它不适用的地方还有IBatis,当IBatis也不适用的地方还会出现或自己创造新的解决方案. 几乎没有一款解决方案能够绝对有效,它只有在恰当的形势下才会发挥应有的作用. 在错误的环境中,它也许会成为毒药.
所以,面对一门新的语言或者工具,无论是你是打算弃若敝履,或是爱不释手推而广之,不妨先想想它的适用环境,尽量做到对症下药,量体裁衣.
... ]]> http://princetonboy.ycool.com/post.3077696.html Tue, 21 Oct 2008 04:10:42 GMT 玩扑克牌与编程