Panic的小屋

FireFox是2008年漏洞最多的浏览器?佩服21cn的垃圾翻译水准..

Panic — Fri, 17 Apr 2009 05:17:00 GMT

作者: Panic 2009年4月17日

原文见:
http://it.21cn.com/software/hydt/2009/04/16/6145294.shtml
这篇报告的英文原始版本见此：
http://www.bit-tech.net/news/bits/2009/04/16/secunia-firefox-most-vulnerable-browser/1

英文水平好的朋友可以直接看原文，就会明白21cn的翻译是多么的蹩脚。
这里只解释几个小细节，粗体字是英文原文

Secunia: Firefox most vulnerable browser

vulnerable 并不是漏洞的意思，vulnerable 的意思是容易受攻击的，FireFox毫无疑问是最容易受攻击的浏览器。。甚至21cn的这篇狗屁翻译也是攻击之一。当然，firefox受到攻击，最大的原因是firefox是开源的，因此每个人都可以阅读源代码，了解其内部实现机制，而寻找攻击的机会。而这恰恰是Firefox更加安全的保证。

It also makes such bugs and their respective fixes uniquely public – where it is easy for Microsoft to quietly fix several bugs in a single patch and tot up only one vulnerability report, Firefox patches outline each problem that is solved and generate multiple vulnerability reports each time.

这段文字说明了，为什么vulnerable报告中，Firefox的统计结果是如此之多，因为Secunia统计的并非实际的漏洞数量，而主要是厂商对浏览器打补丁的数量，对于非开源的IE之流，即使一个补丁里面包含了1000个漏洞，Secunia也只会在报告中增加一个vulnerable计数。而Firefox的升级则是完全透明的，每个人都可以知道某次的升级到底改动了哪些内容。

另外，IE的漏洞统计，并没有把IE独有的ActiveX插件漏洞统计在内，尽管几乎每个使用IE的用户都自己或者被强插了很多带有各种漏洞的插件。。。

当然，我在这里鄙视21cn最重要的原因就是，具有强烈针对性的断章取义，故意歪曲统计结果，在报告原文中有这样一句话：

So is Firefox truly the most vulnerable browser on the market today? Almost certainly not.
翻译如下：
那么，Firefox真的目前市面上是最容易受攻击的浏览器吗？答案无疑是否定的。

Secunia已经明确给出了结论，这个报告的结论就是Firefox并非最易受攻击的浏览器，事实刚好相反，由于开源和频繁的升级修补，Firefox的安全性已经经受住了市场的考验，并且得到了用户的认可。

除了再次鄙视21cn之外，对国内的网络环境也感到进一步的悲哀，真实的东西到了国内，也被歪曲成了虚假的，媒体每一天都堕落的更深，而被愚昧的则是亿万网民。

临时保存

Panic — Fri, 18 Apr 2008 08:34:00 GMT

几个领导者用公款点了一桌丰盛的酒席，飞禽走兽山珍海味应有尽有.这时旁边有几个乞丐在一旁眼巴巴地看着，嘴里不断地流着哈喇子。但是这些领导却不把吃剩下的东西给这几个乞丐，因为领导的脚下还养了几只狗，残羹剩饭是要喂这几只狗的。当然了，这些乞丐连剩汤都喝不着，而领导看着这几个乞丐也很不爽，以至影响了他们喝酒的兴致。这时来了两个外国人看到如此场面,一下子将领导的酒席给掀翻了。这一下领导想起了那几个乞丐，对乞丐说：“帝国主义要来灭亡我们的民族了，必须和他们拼了，这样才能挽救我们的民族。”几个乞丐一听，立即高喊：“领导吃什么是我们自己的事儿，列强掀桌子是我们民族的耻辱。”然后高唱： “起来，不愿意做奴隶的人们.....”抄起打狗棍追着两个外国人打去了.外国人打跑了,几个领导马上高喊：“再来上一桌。”然后又胡吃海喝起来。

你抗议了吗? (转自天涯)
为了GDP，有人疯狂违规卖地，几十万亿亩强行收来，转手就是几百万，你抗议了吗？
　　房价暴涨，多少人穷其一生收入都买不起一个容身之所，你抗议了吗？
　　看一次病，都能收你550万，你抗议了吗？
　　墓地XX万，骨灰盒XX千，都快死不起了，你抗议了吗？
　　几百亿养老钱，让人拿去随意投资，你抗议了吗？
　　倾家荡产供一个大学生，却换来毕业即失业的结果，你抗议了吗？
　　非典当前，掷百姓的生命安全于不顾，可以隐瞒疫情，你抗议了吗？
　　XX省的AIDS疫情被人为的隐瞒了多少年，你抗议了吗？
　　彩票造假，多少彩民的血汗钱被人私分，你抗议了吗？
　　可以深更半夜调印花税，你抗议了吗？
　　用自己手中的非流通股肆意掠夺股民的血汗钱，你抗议了吗？
　　保险公司想圈钱就圈钱，想融资就融资，你抗议了吗？
　　口口声声保证“人民币绝不升值！”，现在都快升了16%了，你抗议了吗？
　　一张虎照，颠倒黑白的指鹿为马，快半年了，都没个交待，你抗议了？
　　多少十几岁的孩子被人卖入黑窑当奴隶，你抗议了吗？
　　矿难曾出不穷，几十上百的生命一次又一次的被埋入地下，你抗议了吗？
　　大火当前，有人高呼“让领导先走！”上百名小学生被烧成焦炭，你抗议了吗？
　　毒大米、毒食用油、毒奶粉、独火腿肠、毒鱼、毒水......快到了无物可食的地步，你抗议了吗？
　　有了点权，就可以开着宝马、奔驰到处撞人，你抗议了吗？
　　因为没有暂住证，就要被人打死，你抗议了吗？
　　为了糊口摆个摊，被人追着满街逃，你抗议了吗？
　　属于你的那个小本上写着“农业”二字，你就要被另一些人歧视一辈子，你抗议了吗？
　　夜总会、娱乐城前，很多车都挂着某种特殊拍照，你抗议了吗？
　　神州大地上，无数顶着国徽的豪华大楼拔地而起，你抗议了吗？
　　对面的小学却没有一间像样的教室，你抗议了吗？
　　几千万在一些人的嘴里竟成了“喝茶钱”，你抗议了吗？
　　运营商提供发展中国家的服务，却按照发达国家的标准收费，你抗议了吗？
　　年薪十万的抄表工，年薪6000万的国企老总，你抗议了吗？
　　雪灾的列车上我们这些贱民受冻受饿时，50名韩国游客被转移到软卧车厢你抗议了吗？
　　一个黄皮肤的中国女孩不知原因的和外国人有关系从楼上跳下去，警方草草结案，你抗议了吗
　　去广交会，要收取外国人不用而中国人要用到良民证，你抗议了吗？
　　
　　
　　
　　国企私有，肥了领导，下岗了职工称为被贪官耻笑的40、50人员，你抗议了吗？
　　香港回归多年，你们可以自由去吗，如果是日本等外国人却可以自由出入没有限期，文字货币都没有统一，连秦始皇都不如，你抗议了吗？
　　中国人在自己国家要办暂住证，你抗议了吗？
　　
　　1.为什么在一千点时放QFII进场？ 2.为什么B股在最高点对国内开放？3.为什么中石油香港发行价格仅1.1港元.大陆发行价格16.7元人民币,高达10多倍.仅0.1元面值的紫金矿业A股发行价人民币7.13元,H股复权发行价0.33港元.相差20倍.公平原则在哪里? 4.为什么一开始就把泡沫化的股票发行给国人,而有投资价值的发行价格1.1港币发给外国人？5.为什么在国外股市最高点对内放行QDII基金？ 6.为什么平安(名为“中国平安”，实为洋人控股)可以如此大规模疯狂抢劫国人的血汗钱？7.为什么美国次债危机刚刚开始发作的时候，却正是QDII出海的时候要国人去买单，这些都是巧合吗？这些你抗议了吗？
　　
　　是谁拿着国家的钱去买黑石基金和美国国债，亏空国有资产，你抗议了吗
　　
　　中国在国际上的形象不是普通老百姓树立的，老外对中国的印象是通过政府获得的，一个欺内媚外的政府是不会有朋友和地位的。

字符串拷贝的小问题

Panic — Fri, 28 Dec 2007 12:33:00 GMT

作者： Panic 2007年12月28日

先看代码：

char buf [20];
strcpy(buf, "abcdefghijklmnopqrstuvwxyz");

呵呵，只有两行，单独看都没错，合起来就麻烦了。
是的，buf的长度只有20字节，无法容纳一个26字符还要外带一个'\0'结尾的字符串。
这个拷贝操作将导致内存写操作越界，从而破坏其他地方的数据。

这并不是一个很难发现的错误，但是当buf的定义和拷贝的时机相隔很远，或者频繁使用了strcat一类函数而忽视了字符串长度的时候，想要找出这个问题，还是比较麻烦的。

解决方法有几种，最简单的就是定义足够大的缓冲区，比如当拷贝路径的时候，使用MAX_PATH宏。但是这有时候不太现实。
我们也可以使用一个string类来管理，比如MFC的CString，或者STL的std::string，都可以，当增长的时候只要调用operator +就可以了。
还有一个方式是使用strncpy，强制每次拷贝都输入一个长度参数。当然，这个参数的数值一般是buf的长度减1，buf的最后一个字节，则在初始化的时候就应该赋值为'\0'。这可以避免很多问题，但是遇到strcat的时候仍旧会有潜在危险，你可以考虑使用strncat，虽然这会带来额外的复杂性。

有符号 & 无符号！改变计算结果的陷阱！

Panic — Wed, 05 Dec 2007 12:09:00 GMT

作者： Panic 2007年12月5日

简单的代码，复杂的问题。
环境：VC6SP5,Win2kPro

int b = 10; //已经赋值为有效数据
const char * str = "1234567890ABCDEF"; //已经赋值为有效的字符串。
int a = (b - strlen(str) ) / 2;

经过了这样的计算，a的值究竟是多少？
结果当然不是 (10-16)/2 的 -3，而是一个天文数字。。。。
a = 2147483645 或者，16进制的 0x7ffffffd

真正的问题代码只有一行，但是结果却令人不快。

这里分析一下产生这个问题的原因：
一个隐含的问题是，strlen的返回值，类型是size_t，也就是unsigned int。这是个无符号类型。
当unsigned int 和 int混合运算的时候，编译器会认为，unsigned int的表达长度比较长，因而结果的类型是unsigned int。
所以 b - strlen(str) 的结果不是 -6，而是和-6具有相同内存布局的unsigned int 值：0xfffffffa，也就是正的4294967290
如果这个数值直接赋值给int，会因为内存布局相同，而避免问题的产生－－问题存在，但是不产生不良效果。但是随后的/2操作把问题彻底暴露出来了。。
/2操作可以认为是一次移位，对于无符号类型，移位后高位补0，于是把原本有符号类型赖以利用的符号位清零了。。最终这个数值赋值给int类型的时候，结果就变成了前面提到的那个可怕的数值。。

有符号数字和无符号数字混合运算的时候，存在一些默认的转换规则，符合这些规则的转换，都不会引发编译器警告或者错误，因此这类问题是难以觉察的。但是，我们需要经常使用的库函数太多了，当参与运算的时候，为每个函数调用都指定一个固定类型的返回值，似乎是不可能的任务。因此如果你的程序中充满各种不同类型的整型运算，那么还是尽量小心一些吧。。。

不同种类的整型比较，到底发生了什么？

Panic — Tue, 17 Jul 2007 03:31:00 GMT

看这么两行代码：
int i = -1;
cout << (char(i) == unsigned char(i)) << endl;
在VC6.0下，永远输出0。而下面这两行代码也永远输出0
int i = 255;
cout << (char(i) == unsigned char(i)) << endl;

而实际上，以上两个代码中，char(i)和unsigned char(i)具有的内存布局都是完全相同的。由于整型之间的类型转换遵循这样的原则：当目标类型比原类型短的时候，直接截断原类型。而当目标类型较长，则无符号类型会直接在高位补0，有符号类型在高位补符号位。

在VC6下，而当两个长度相同，并且具有相同内存布局的整型相比较的时候，编译器做如下的工作：
首先两者长度<=int的长度的时候，全部转化为int，然后实施比较。
所以char(-1)转化的结果是0xFFFFFFFF，而unsigned char(-1)转化的结果是0x000000FF。两者作为int比较的时候，自然是不相等的。
但是，特别的，当两者长度刚好是int长度的时候，比较的结果仅取决于内存布局，而有符号和无符号的转化也不会改变内存布局。

这个事实引起了一个问题，当我们使用char/unsigned char,short/unsigned short这类比int短的类型的时候，无符号类型的变量是绝对不会和有符号的-1相等的，而使用int的时候，int(-1)和unsigned int(-1)则是完全相等的。这使得修改变量类型会引发比较结果的变化，尤其是在做变量扩展，或者在模板代码中这个问题有可能会引发难以觉察的错误。

对这个问题的建议是：永远都不要进行有符号类型和无符号类型之间的数值比较，不同长度的类型之间的比较也要尽量避免。

vck博客的评论验证码是不是形同虚设啊?

Panic — Mon, 30 Apr 2007 09:45:00 GMT

几天没注意,广告一大堆啊.....

javascript版本的二分查找算法

Panic — Fri, 13 Apr 2007 03:43:00 GMT

/* javascript版本的二分查找算法，支持自定义的less_than函数 */
/* 作者： Panic  2007年4月13日 */
/* 网站： blog.vckbase.com/panic */
/* 参数说明：*/
/* arr:数组，下标必须从0开始，并且是连续非负整数，包含要查找的内容，必须是排序好的 */
/* item:要查找的目标 */
/* less_than:比较函数，定义为：function less_than(left,right) */
/* 这个函数必须和数组用于排序的less_than函数具有同样的行为 */
/* 当left < right时，返回-1 */
/* 当left == right 时，返回 0 */
/* 当left > right时，返回 1*/
/* 返回值说明：*/
/* 当目标存在时，函数返回目标所在位置的数组下标 */
/* 当目标不存在时，函数返回数组中第一个比目标大的元素下标 */
/* 当查找的目标比数组中任何元素都大，或者数组为空的时候，返回数组的长度 */
    function binary_search(arr,item,less_than)
    {
        var start = 0;
        var end    = arr.length
        var current = (arr.length + (arr.length%2) )/2; /* 晕死了，直接写var current = arr.length/2; 就会出错 */
        while( end != current )
        {
            if( less_than(item,arr[current]) == 1 )
                start =    current+1;
            else
                end = current;
            var tmp    = (start + end);
            current    = (tmp - (tmp%2))/2; /* 直接写 current = (start + end)/2; 也会出错，晕ing */
        }
        return current;
    }

代码描述已经很清楚了，里面两个注释是让我觉得莫名其妙的地方，期待指教。。。
如果按照注释中的写法，IE解析出错。。。

经周星星同学指点，发现问题是IE6下，javascript不支持浮点数到整数的自动截断引起的，代码改为：
var current = Math.floor(arr.length/2);
和
current = Math.floor((start + end)/2);
即可。

在candlepowerforums发现一个有趣的图标:)

Panic — Tue, 03 Apr 2007 11:45:00 GMT

很形象的反映了一些用户对IE和Firefox的不同态度。

IE7似乎并没有给用户带来更多惊喜，倒是FireFox赢得了更安全更有效的名声，多种多样的扩展提供了强大的功能选择，再加上Google的参与，在推广Google Toolbar的过程中，在googler的圈子里面扩大了Firefox的影响力。

Firefox的中文官方网站是
www.mozilla.org.cn
在这里可以获得不包含扩展的Firefox中文版本下载。所有的扩展都可以由用户手动安装和删除，这和在IE下想删除一个ActiveX的费力有着本质的不同。

经过了几年的发展，Firefox已经今非昔比，那个堆积着各种bug，残留着linux晦涩的用户界面的Firefox已经一去不复返了。简洁的操作，丰富的功能，Firefox已经成功的植身于微软庞大的操作系统之中，成为越来越多用户新的选择。

配置apache，Cannot load php5apache2.dll的错误解决

Panic — Wed, 07 Feb 2007 13:08:00 GMT

被这个问题困扰了一个晚上，搜索了很久都没有找到解决办法。
最后无意间看到这个：
anthony 发表于2006-07-21 15:19:00 IP: 221.223.64.*
关于 "cannot load php5apache2dll" 的问题，是因为php自带的php5apache2.dll只能跟某个特定版本的apache2使用的缘故。只需要到 http://www.apachelounge.com/download/ 下php5apache2.dll-php5.1.x.zip 然后照里面的说明跟着做问题就解决了。

我下载的apache是最新版，貌似php还没有制作对应的php5apache2.dll文件，所以出错了，重新安装了一个旧版的apache就解决了。

郁闷。。。

暂时纪录

Panic — Wed, 03 Jan 2007 16:37:00 GMT

12bit串行DAC
TLV5616

10bit串行DAC
TLV5606
www.metacafe.com

http://ajaxpatterns.org/archive/IFrame_Call.php

八皇后问题？
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

long sum=0,upperlim=1;

void test(long row, long ld, long rd){

if (row != upperlim){
long pos = upperlim & ~(row | ld | rd);
while (pos){
long p = pos& -pos;
pos -= p;
test(row+p, (ld+p)<<1, (rd+p)>>1);
}}
else
sum++;
}

int main(int argc, char *argv[])
{
time_t tm;
int n=8;

if(argc!=1)n=atoi(argv[1]);
tm=time(0);
if((n<1)||(n>32)){
printf(" heh..I can't calculate that.\n");
exit(-1);}
printf("%d Queens\n",n);
upperlim=(upperlim<<n)-1;

test(0,0,0);
printf("Number of solutions is %ld, %d seconds\n", sum,(int)(time(0)-tm));
}

昨天刚听到的一首歌：《Be What You Wanna Be》

Panic — Wed, 27 Dec 2006 06:21:00 GMT

by Darin

Doctor actor lawyer or a singer
why not president be a dreamer
you can be just the one you wanna be
police man fire fighter or a post man
why not something like your old man
you can be just the one you wanna be
doctor actor lawyer or a singer
why not president be a dreamer
you can be just the one you wanna be
i know that we all got one thing
that we all share together
we got that one nice dream
we live for
you never know what life could bring
coz nothing last for ever
just hold on to the team
you play for
i know you could reach the top
make sure that you won't stop
be the one that you wanna be
now sing this with me
doctor actor lawyer or a singer
why not president be a dreamer
you can be just the one you wanna be
police man fire fighter or a post man
why not something like your old man
you can be just the one you wanna be
we may have different ways to think
but it doesn't really matter
we all caught up in the steam
of this life
focus on every little thing
that's what does really matter
luxury cars and bling
thats not real life
i know you could reach the top
make sure that you won't stop
be the one that you wanna be
now sing this with me
doctor actor lawyer or a singer
why not president be a dreamer
you can be just the one you wanna be
police man fire fighter or a post man
why not something like your old man
you can be just the one you wanna be
last year i used to dream about this day
now i'm here i'm singing for you
i hope i could inspire you
coz i've got all the love
coz i've got all love for you
doctor actor lawyer or a singer
why not president be a dreamer
you can be just the one you wanna be
police man fire fighter or a post man
why not something like your old man
you can be just the one you wanna be
doctor actor lawyer or a singer
why not president be a dreamer
you can be just the one you wanna be
police man fire fighter or a post man
why not something like your old man
you can be just the one you wanna be
doctor actor lawyer or a singer
why not president be a dreamer
you can be just the one you wanna be

关于今日网络故障的公告

Panic — Wed, 27 Dec 2006 05:52:00 GMT

由于本人洗脚时不慎踩断链接美洲，亚洲的海底光缆，引起亚太地区网络故障。本人对此深表遗憾，如有雷同纯属巧合～@@

英雄无敌3技巧心得

Panic — Tue, 26 Dec 2006 09:07:00 GMT

英雄无敌3技巧心得

作者： Panic 2006年12月26日

《英雄无敌3》，3DO公司永恒的经典。

给个下载地址：http://dlga.pchome.net/games/demo/classic/H3.exe

作为一款成功的2D回合制策略游戏，英雄无敌3至今仍然拥有大量的玩家，我也是其中之一。

在这里我写一些自己玩这款游戏的一些经验和心得。

和其他玩家交流的过程中，经常听到别人讲一些兵力过千的所谓经典战役，个人却深不以为然。

以个人看法，英雄无敌3随着玩家水平的提升，有三个阶段：战斗阶段，战术阶段，和战略阶段。

战斗阶段是最初的阶段，玩家只是掌握了游戏基本的操作，通常会选择难度较低的关卡或者地图。这个阶段的玩家，对于兵种搭配和战术技巧缺乏经验，所以以自动战斗或者手动战斗的方式进行对战，结果相差不大。

为了赢得胜利，玩家大部分时间在扮演“建设者”的角色，把建筑物都造到最高等级，积累足够数量的高级兵种，然后和对手决战。

多数人喜欢把全部兵力集中在一个最强的英雄手里，甚至自己的城里都不留什么防守部队。一旦最强的英雄被消灭，也就意味着最终的失败。

S&L(Save & Load)是这个阶段无可避免的。

由于兵力是决胜的唯一要素，这个阶段的玩家会比较喜欢拥有强大的兵种，比如天使，黑龙，泰坦，进而喜欢对应的种族。

拥有高级的初始魔法的英雄也是大家所亲睐的，比如拥有连锁闪电，流星雨，转世重生一类魔法的英雄。

在城堡建设方面，除了希望能够快速建造出最高级兵种之外，魔法塔的升级也是很勤奋的，4级以上的魔法塔可以提供更多更强大的魔法，是这个阶段强有力的工具。

比较受欢迎的魔法有如下几个：末日，爆裂术，连锁闪电，流星火雨，回城术，次元门，飞行术，等等。

辅助技能中，智慧术是必不可少的，四大元素魔法也是优先选择的。很多人也非常喜欢外交术，这一种快速积累兵力的途径。在比较大的地图上，后勤术和寻路术也有很高的价值。对于魔法型英雄，智力和魔力也是不可或缺的。

这个阶段的玩家多数时候奉行的原则是S&L。

战术阶段是玩家水平提高之后的阶段，由于掌握了更多的战斗技巧和操作经验，玩家可以在魔法塔和高级兵种出现之前，进行更多的战斗。

这个阶段，由于4级魔法塔和6、7级兵出现之前需要进行艰苦的战斗，那些高级但是却可望而不可及的魔法和兵种无法发挥作用，低等级的兵种成为战斗的主力。

这时候比较有吸引力的兵种一般都是远程，或者不被反击的兵种，快速兵种也是重要的战斗力。比如吸血鬼，弓箭手，大精灵，美杜沙等。这个阶段的玩家对于不死族有特别的感情，吸血鬼作为唯一一种可以自我复活的兵种，经常被称为同等级中最有效的兵种。

很快，低级兵种消耗殆尽之前，6级兵的出现改变了局势，一跃成为战斗主力，6级兵中，恐怖骑士是最具战斗力的角色。

除了拥有高级初始魔法的英雄外，拥有外交术，或者一些辅助法术的英雄也经常被人使用。

城堡建设方面，魔法塔的建造被推迟了，而最高级的兵种在相当长的时间内是不列入建造名单的，节省下来的时间和金钱用来尽可能多的获得6级和以下兵种的数量。7级兵经常在3～4周后才出现，最初的7级兵也只是为了提升首发速度和给予对手最后一击，在数量到达两位数之前无法成为战斗主力。

比较受欢迎的魔法里增加了很多低等级的战斗魔法，比如闪电，火球，失明术，减速，加速，祝福，等等。这个阶段的玩家也喜欢在战斗前用魔法查看对方的详细兵力，然后针对性的展开攻击。

辅助技能中，外交术的地位极大提升，由于兵力栏位经常有空缺，半路获得的兵力补充就更加宝贵。同时，领导术和幸运术的地位也随着提升。攻城术也受到相当的欢迎，缺乏了7级兵种的强力压制，攻破城池需要的时间更长了，攻城术可以有效减少自己兵力的损耗。

这个阶段的玩家喜欢的原则是不打无把握之仗，S&L的次数极大减少了，只有在很关键的决战前才会使用。

这时候，玩家会放弃低难度的地图和关卡，不断挑战160%和200%的难度，并且以高难度下获得的高积分作为炫耀的资本。由于200难度下，敌人和地图上兵力的积累都很惊人，而一张地图经常需要耗费6个月以上的游戏时间，最终的战斗很容易变成千人大战，甚至7级兵的数量也达到4位数。

战略阶段是战术阶段后，完全掌握了战术技巧后，在对游戏整体把握的层次上进行游戏的阶段。这个阶段最显著的特征是速战速决，

在这个阶段，大量的战斗发生在4级以下的兵种之间，而魔法塔经常保持在一级或者二级。

由于资金的匮乏，拥有理财术或者天生增加资源的英雄成为首选。

这个时候，比较有吸引力的兵种一般都是低级远程兵种，低级快速兵种，以及数量可以近乎无限积累的骷髅兵。

除了具有资源产出能力的英雄外，擅长某种低级兵种的英雄由于可以在雇佣的同时携带大量兵力，也受到很大欢迎。

城堡建设方面，魔法塔的建设在一级之后就被置之不理了，获取魔法经常是在占领了敌人的城堡之后。资源建设是这个阶段的重点，快速提高各种资源产量是取得胜利的关键，除了建设自己原有的城堡外，尽可能快的占领新的城堡是最有效的方式。

比较受欢迎的魔法增加了两个极具战略意义的一级魔法，查看空气和查看大地，前者可以洞悉地方城堡和英雄的位置，后者则可以查看地形和资源分布。这两个魔法配合，为英雄提供了超视距攻击的能力，极大提高了攻城和守城的把握。

辅助技能中，土系魔法和气系魔法成为必须，和智慧术一起，构成英雄技能的三大支柱。而其他的辅助技能除了一些确确实实的鸡肋之外，都可以有效发挥其作用。

这个阶段，玩家能够精确的估算战斗结果，能够细致入微的调动每一只部队，S&L变成一种耻辱。与此同时，玩家可以以更短的时间完成前两个阶段的地图。由于时间的缩短，兵力的积累受到极大限制，除非是城堡非常多的地图，否则7级兵的数量一般在两位数，只有最后的决战才有可能达到三位数，但是这时候这种数量的兵力已经没有什么意义了。

战略阶段之后，是否还有更高层次的阶段，我就不知道了，希望有更高水平的玩家能给予提示。下面我介绍一些游戏的小技巧，主要针对战略阶段。

早期建设：

资源相对比较充裕的地图，首都建造是必须的，一般在10天（160%）或者20天（200%）内就要完成，有了首都可以极大提升金钱的收入，为以后的建筑和兵力提供足够的积累。

如果资源相对匮乏，则把钱节省下来建造一些兵种。然后依靠兵力打通道路寻找资源。

兵种方面，一级兵是必须造的（废话），而如果兵种升级能变成远程（比如泰坦城1级兵），或者不受反击（比如地下城2级兵），那么升级也是必须的。

资源的使用经常需要精确到个位数，在市场中进行资源交换也是常有的事情。

最初的战斗：

一般的，最初的战斗你只拥有1级和2级兵种，偶尔会有少量三级兵。在没有远程部队的时候，英雄的部队要这样分布：最强的兵力集中在最下方（战斗地图），而上面的部队都是一只或者能承受1次攻击而不全灭的兵力。

这么做的目的是，你先以横向移动的方式将兵力集中，通过减速或者加速的魔法设法拉开敌方部队之间的距离，以上部的少量兵力耗费敌人的攻击和反击的机会，随后以最强兵力尽可能在最少的攻击次数内消灭对手。敌我兵力接近的时候，这种战术可以把己方损失降到最小。

如果你的部队中有一定数量的远程部队，那么远程部队应该放在最上方的角落，这个位置在同样速度下，拥有首先攻击的地利，同时，只需要2～3只其他部队就可以保护其不被近身。

剩余的部队目的主要是吸引敌人的部队，让他们尽量处在远程部队的射程内（指攻击不减半的距离）而又不能直接威胁远程部队的安全。如果你有祝福等魔法，可以令远程部队发挥更大威力。

以这种战术，可以以最小的代价消灭掉比你实力强的部队，从而为外出探索打开大门。在探索到的范围内，优先攻击有可能通往其他城堡和资源的道路上的部队。

这时候你唯一惧怕的兵种就是远程兵种，不过如果你拥有一级魔法塔或者一个攻击法术的话，你的损失也不会太大。

依靠这最初的部队，你的英雄要尽可能远走，越远就意味着越多的资源被发现。经常的，第一支部队会以消耗殆尽作为终结，而随后的第二支部队则攻占了第一个城堡。

随后的发展：

如果你探索到了足够的资源，而敌人的踪迹还未发现，你可以优先建造首都，随后的过程就和玩低难度没什么太大区别了。

如果探索到了敌人占领的矿，或者地面上有资源被拣走的空旷感，占领敌人的城堡就成为最大的目标。

在200%难度下，这个时候的敌人通常是比你强的，兵力可能是你的数倍，而城堡建设也比你更完整，你可以冒险前冲，直接探测敌人的城堡位置。而攻城的时间最好选择在周六，周日或者周一（如果你首先行动）。

如果运气好，这一步就可以攻城得手，然后以一周兵力守城。如果有三个箭塔，一般来说是守的住的。即使没有守住，敌人的实力也大大削弱了，而且位置也明确了，后面的攻击就更有把握。

如果因为守兵太强无法攻城，或者守城部队被灭，下一步的计划就是趁敌人主力部队离城的时候偷袭，偷袭的成功率非常高，十之八九会成功，而且偷袭成功后守城基本也会成功。

如果你的英雄在路上就被敌人消灭了，你只能准备下一步探测。

守城有个窍门，如果你的兵力不足以守城，可以分7只放在城里，而英雄跑到安全的地方。这样敌人在夺回城的过程中会面临箭塔射击而损失兵力，同时敌人的主力部队会被牵制在城附近，你可以趁机抢夺周围的资源。

这个守城的窍门在1v7的时候是必须的，你必须尽可能把敌人牵制在城的附近，才能更好的保证你已经占领的城堡的安全。

第一个城是胜利的关键，在城堡比较少的地图，占领一个城一般就意味着一个玩家被消灭了。拥有两个城堡，你的资源和兵力基本可以面对任何敌人了。

夺取第一个城之后，你的英雄一般可以升到5级左右，运气好的话，你已经拥有初级级土系或者气系魔法，并且拥有透视空气和透视大地的至少其中之一了。

这时候，立刻用强势兵力清除城堡周围的小怪，尽快获得专家级的土系或者气系魔法。这里土系比较优先，因为通过观察地图上的资源占领情况就可以猜测敌人城堡的位置，而气系虽然能看到位置，却不容易找到进攻的途径。当然两者都有是最好的了。

获得下一个目标位置之后，仍然采用原先的牵制+偷袭策略，可以轻易消灭下一个对手，然后你就拥有至少3个城堡。以后的故事就没有任何悬念了。

如果地图上城堡非常多，建设就成为昂贵的开销，这时候要优先建造可以固守的城堡的资源，而前沿城堡可以置之不理，或者在资源充足的情况下优先发展防御。

其他技巧：

寻找神器：

神器，无论是为积分还是为神器的作用，都是必须寻找和挖掘的。找到一个方尖塔之后，神器所在的地形就可以确定，3座方尖塔之后，如果你拥有专家级土系魔法和查看大地，只要够耐心，你就能够定位神器所在。

一旦神器的位置被锁定，你可以不惜一切代价打开通往神器的路径，然后用人海战术挖掘神器（你也可以用S&L）。同时利用距离神器最近的城堡作为基地击退来袭的一切敌人。

找到神器之后，让最强的英雄带着它去你最中意的城堡，一般的选择是元素城。得到神器也就锁定了胜局。

神器的窍门，神器只能位于距离地图边界超过9的地方，所以中心地带有更多的机会。敌人也会挖掘神器，你可以通过查看收入和城堡数量的排名评估神器是否已经被挖走。当然，也可以从神器的效果观察。

如果刚好碰到敌人也在挖掘神器，你可以从敌人的行为判定神器是否已经被挖走，确定没有挖走的话你最好消灭掉敌人的挖掘部队然后取而代之。

屠龙：

地图上有可能存在龙城（抱歉，我一直是玩英文版的，不知道这个次汉化版具体是什么，可能是龙之殿堂一类的），龙城的强度以其中的黑龙数量为准，通常是1～5只，而金龙，红龙，绿龙的数量依次增多。

龙城可以随机出高级的宝物，黑龙越多宝物也越多，这些宝物能极大提升英雄的实力。一般情况下，在6级兵过12只或者同等兵力的时候就可以屠龙，如果有转世重生一类的法术，甚至可以无损。龙的可怕之处在于魔法的免疫，而两格的攻击范围经常成为其自相残杀的手段。

除非运气特别差，否则屠龙得到的好处都将远远超过你的损失。

航海：

在有海的地图，航海是极其重要的行动，海上可以拣到大量木材和相当数量的金钱，很快就能弥补造船的费用，还有相当多的场合能得到宝物。

不过上岸/上船需要消耗全部移动力，最好派遣闲杂英雄出海拾荒，同时英雄最好有战术学，以便在遇到敌人的时候可以先机逃跑。

接力运兵：

接力运兵是偷袭和攻城的必备技巧。方法很简单，英雄1首先出发，第二天英雄2走到英雄1前一天的位置，而英雄1继续前进，依次类推，由于最多可以雇佣8个英雄，所以英雄1最后可以位于距离城堡7天路程的地方。

第八天，城里雇佣一个英雄，带着所有兵力依次向前接力，最后送达英雄1的手里，英雄1继续前进，可以到达8天路程的位置。

一般的地图，两个相邻城堡之间的距离不会超过8天，所以这个方法非常适合快速集合兵力和攻城。

换城战术：

在200难度下，当敌人首先攻击自己，而自己尚没有实力与之抗衡的时候，可以让主英雄携带所有兵力直扑对方主城，而其他英雄吸引敌人主力占据己方城堡。结果就是敌我城堡互换，但是由于敌方城堡建设程度一般比自己要高，所以这个互换是非常有价值的。

换城战术也经常在战役地图中使用。换城会导致敌人已经积累的强势兵力无法继续累积，从而削弱战斗实力。

弱势诱敌：

操作技巧足够的时候，以弱胜强是可能的，故意在城堡中放置相对薄弱的守兵，诱使敌人的部队前来进攻而歼灭之，这是个有效的战术但是有一定风险。

如果放置的兵力太强则敌人不会进攻，太弱则会被攻克，如果没有足够精确的推算能力，还是少用为妙。这个战术通常需要一个法师型英雄作为守城核心。

杀英雄：

这是个重要的战术，当和敌方高等级的英雄战斗的时候，消灭其兵力到一定程度的时候，敌人会逃跑，逃跑之后的敌人虽然没有了兵力，但是技能和等级，宝物仍然在，有了兵力仍然具有相当的战斗力。

杀英雄的作用在于可以夺取对手的宝物，消灭高级英雄，使其一蹶不振。

杀英雄一般有两种方法，一种是使用失明等法术进行控制，使敌人没有机会行动，

另一种是先消灭敌方快速部队，确保自己拥有最快行动速度，然后在适当的时候所有部队都等待，等对方行动完之后，魔法攻击一次，然后所有部队攻击一次，下一回合开始，又可以魔法攻击一次，所有比对手快的部队又可以攻击一次，这样造成连续的4次攻击，基本可以消灭敌方剩余部队而杀死其英雄。

当然有一个宝物似乎叫做“战争镣铐”是可以防止对手逃跑的，同时自己也不能逃跑。

己方英雄的数量：

多数时候，主英雄只有一个，同时负责攻守的任务，携带几乎全部的有效兵力。

当地图大一些，或者探索的范围扩大之后，推荐培养一个新的英雄作为第二战斗力，这个英雄携带更适合防守的兵力，主要任务是守城，在兵力超过一定数量的时候也展开攻击。

即使是超大（XLarge）地图，战斗英雄一般也不超过4个，偶尔雇佣到敌方死去的高等级英雄，可以放置在城堡内留用。

每个战斗英雄都有明确的目标，守城英雄一般都要有魔抗和战术，射术等有利于守城的技能，而攻城英雄则优先发展提升攻击力和移动力的技能。

同时控制多个战斗英雄的时候，兵力的分配是十分重要的，主英雄的兵力可以比敌人最强的部队少1～2周的兵力，这基本上就可以防守住新占领的城堡。第二英雄携带的兵力可以比主英雄更强，以便弥补因为宝物数量和等级造成的战斗力差距。其他英雄如果可能，尽量携带能够防守住其活动区域的兵力，如果实在兵力匮乏，也要携带4只以上部队，以免在战斗中被轻易杀死而白送给对手500经验值。

大的地图，多线作战是必须的，否则敌人的兵力会过分累积导致游戏时间拖长。你能够同时控制的具有战斗力的英雄越多，消灭敌人的速度也就越快。英雄的兵力视对手状况而定，如果已经够用，就把多余的兵力分配给其他英雄，提升多线作战的能力。

城堡攻守的策略：

城堡比较多的时候，相邻城堡的位置会比较接近，这时候需要根据城堡的相对位置决定攻守的策略。

一般的，处在多个敌方城堡之间的城堡不容易防守，一旦防守部队离开就会面临丢失的危险，这时候如果有足够的部队，就要坚决守住，以便遏制对手进入自己后方阵地的速度。如果兵力匮乏则最好放弃过分前沿的阵地，而把防守的力量都集中在后方。

偏远的城堡不容易遭到进攻，但是一旦被占领就不容易夺回来，如果能在去往这类城堡的路上加以堵截，这些城堡可以作为小金库。

对方的首都永远是优先攻击的目标，你可以尝试丢了首都是怎样一种感觉。首都作为最初兵力的发源地，距离后来占据的城堡都比较近，很容易形成破竹之势一举歼灭一个玩家。

消灭玩家的策略：

你可以通过侦察，酒馆等得到各种敌人兵力的数据，如果你的主英雄已经拥有压制任何单个对手的兵力，那么优先挑战对方拥有最强兵力的英雄，一旦这个英雄被消灭，其他的部队就可以交给你的第二战斗英雄或者其他英雄来解决。

如果敌人的实力强过你太多，则优先攻击距离你比较近而防守相对薄弱的玩家。

当一个玩家的实力被极大削弱之后，要尽可能在短时间内消灭他，经常的，你只需要派第二甚至第三英雄就可以将其赶尽杀绝。

战斗力的评估：

为了达到快速杀敌的目的，兵力损耗是不可避免的。当完成一张地图的时候，如果你手上仍然剩余大量几乎从未参加战斗的部队，那么你的进攻技巧需要改进，因为太多的部队没有发挥出作用。

精确的评估消灭对手所需要的兵力，是充分调动你的战斗力的前提，只要损失数量在许可的范围内，战斗就是值得进行的，以“无损”为目标的战斗通常都会极大拖延时间。

暂时写这么多，以后有时间再补充:)

游戏的积累特性（游戏设定连载之二）

Panic — Wed, 20 Dec 2006 02:35:00 GMT

游戏的积累特性（游戏设定连载之二）

作者： Panic 2006年12月20日

这里所说的游戏并不仅限于电脑/电子游戏。

游戏的积累是指，当玩家投入更多时间，精力，物质等进入到游戏当中之后，玩家所获得的对于未来进行游戏的有利因素的总和。

举例来说，篮球，经过了更多的训练和比赛，玩家的各种技术会得到不同程度的提升，从而增加以后战胜对手的机会，这种技术的增长就是积累。

积累分为两种，一种是规则内优势积累。一种是熟练度积累（也可以叫规则外优势积累）。

规则内优势积累是指这样一种情况：玩家在先前游戏中获得的有利因素可以保存，从而在以后的游戏中在一开始就获得有利的位置。

这种积累最典型的就是普通的网络游戏中，等级和装备的积累。拥有了更高等级的玩家可以在以后的游戏中以更大的优势取得胜利。

规则内积累导致的后果就是，游戏的胜负在更大程度上受积累总量的影响，而由于积累是有限度的，所以最终游戏的寿命是有限的。

熟练度积累是指玩家自身实力的提升，这种提升和规则无关。

比如经过训练，一个田径选手的速度提升了，但是在比赛中，他不能因为实力提升而把起跑线向前移动哪怕一丝。所有的人还是要从相同的起跑线展开竞争。

再比如扑克，水平再高的人也没有权力比对手多抓几张牌。

熟练度积累导致的后果是玩家的胜负受玩家自身实力影响，而规则是完全公平的。由于自身实力的提升几乎是没有限度的（所谓人外有人），而熟练度本身还会由于生疏而下降，导致实力提升过程出现反复。游戏的寿命可以说是无限的。

现在广为流传的游戏，基本上都是单纯熟练度积累的游戏。而且，能够用于比赛的项目也必须是单纯熟练度积累的。

单纯熟练度积累的游戏，才是公平的游戏。

规则内优势积累的速度，极大程度上受规则本身的影响，规则的少许变动就会导致积累速度的显著改变。在游戏的整个生命周期中，不同阶段规则经常是不同的，在规则改变导致积累速度降低的时候，新加入的玩家就会怨声载道，而规则改变引起积累速度增长的时候，老玩家就会发现新手能够用更少的代价达到他们的水准。

在多数情况下，后加入的玩家几乎无法达到和早期玩家同样的高度，由于同一规则下，积累速度是一致的，老玩家现有的积累部分就永远无法被超越。

在现有的网络游戏中，一般都是通过一些条件（比如经验值）近乎无限的增长需求来限制玩家最终所能达到的积累数量，但是毫无疑问，当玩家从积累状态转变到静止状态的时候，游戏其实已经不是原有的游戏了。

规则外积累的速度，基本只受玩家自身努力程度的影响，同时玩家的先天条件也会起到相当的作用（比如天生身材高大的就比较容易在篮球运动中取得优势地位）。在游戏的整个生命周期中，规则是不会有大幅度改变的。而且，规则的改变对于积累速度的影响相对也比较小。

有了前辈的经验，后加入的玩家往往可以在更短的时间内达到和早期玩家同样的高度，但是在这个高度上的突破，所有人又都回到了同一个起跑线上。

游戏的公平，不但体现在了每次游戏之中，而且体现在游戏的整个生命周期中。

熟练度的积累不需要进行任何限制，他的极限也就是人的极限，能够达到自己极限的人是屈指可数的，大部分的人都处在积累过程或者放弃过程中。

在设计一个游戏的时候，游戏是否允许规则内积累，是决定游戏宏观寿命的决定性因素。

不过很遗憾的是，在网络游戏的风潮中，积累似乎变成每款游戏的标准配置了。暴雪在设计WOW的时候，抛弃了级别积累可以说是一个创举，但是用装备积累取而代之则又回到了老路。

星星出的丢玻璃棋子的题目，我的解法

Panic — Thu, 07 Dec 2006 07:55:00 GMT

星星链接：
http://blog.vckbase.com/bruceteen/archive/2006/12/07/23394.html
原题：
问题：
有一幢100层高的大楼，给你两个完全相同的玻璃棋子。
假设从某一层开始，丢下玻璃棋子就会破碎。那么怎么利用手中的两颗棋子，
用一种什么样的最优策略，知道这个临界的层高呢？

我的解法，保证所有最坏情况下，需要丢棋子的次数为一个有限次数。
原理如下：
首次丢棋子的位置是可以有变化的，第二次丢棋子则只能从最近的没有破的那一层向上依次丢，不然就得不到结果。
假设极限次数限制为n，那么丢了m次棋子之后，剩余的层数必须等于n-m才能保证能在n次内找到答案。
题目变成求这个n的最小值。
用逆推法，100层是不用考虑的，如果99层丢没有破，答案就是100层。所以最坏情况下，最后一次丢棋子是在99层。
倒数第二次要保证如果没有破，则只剩1层需要测试，如果破了，则也只有一层需要测试。
倒数第二次只能是98层，其后需要测试的两层分别是99和97。
倒数第三次就只能是96层，96层如果破了，有两层需要测试，向上就是98和99（或97），向下就是95，94。
所以倒数第四次一定是93层。
依次类推，最后得到一个逆序数列：
99,98,96,93,89,84,78,71,63,54,44,33,21,8
这个数列逆过来，就是丢棋子的正确顺序。
代码如下：

#include <iostream>
using namespace std;
bool throw_at(int i)
{
    int result = 55; //set the result
    if( i >= result ) return true;
    return false;
}
int foo()
{
    int array[] = {1,8,21,33,44,54,63,71,78,84,89,93,96,98,99};
    int count = 0;
    for( int i = 1; i < ( sizeof(array)/sizeof(array[0]) ); ++i )
    {
        bool broken = throw_at(array[i]);
        ++count;
        if( broken )
        {
            for( int j = array[i-1]; j < array[i]; ++j )
            {
                if( throw_at(j) )
                {
                    ++count;
                    cout << "Throw " << count << " times." << endl;
                        cout << "Result is: " << j << endl;
                    return j;
                }
            }
            cout << "Throw " << count << " times." << endl;
                cout << "Result is: " << array[i] << endl;
            return i;
        }
    }
    cout << "Throw " << count << " times." << endl;
        cout << "Result is: " << 100 << endl;
    return 100;
}
int main(int argc, char* argv[])
{
    foo();
    return 0;
}

sysinternals的各种系统管理工具下载

Panic — Wed, 06 Dec 2006 06:10:00 GMT

sysinternals原来是一个独立团队，开发了一系列信息监控和修改的工具。现在sysinternals被微软吃掉了，不过开发并没有停止：
详情访问主页：
www.sysinternals.com
另外blog似乎有个bug，我输入www之后，如果紧跟着一个 . 就会死掉半天。。

CMonthCalCtrl的一个BUG

Panic — Wed, 06 Dec 2006 03:38:00 GMT

环境：win2k pro, vc6.0 sp5
bug描述：
CMonthCalCtrl::GetCurSel函数的返回值是错误的。

测试代码：
//CMonthCalCtrl m_c; //定义在某处。
//当用户选择了不同的日期后
CTime t;
m_c.GetCurSel(t);
CString s = t.Format( "%A, %B %d, %Y" );
//之后s的值和用户选择的数值相去甚远。

bug跟踪：
通过简单的跟踪，发现问题出在控件本身对消息的响应上，在winctrl5.cpp中：
BOOL CMonthCalCtrl::GetCurSel(CTime& refTime) const
{
ASSERT(::IsWindow(m_hWnd));

// can't use this method on multiple selection controls
ASSERT(!(GetStyle() & MCS_MULTISELECT));

SYSTEMTIME sysTime;
BOOL bResult = (BOOL)
::SendMessage(m_hWnd, MCM_GETCURSEL, 0, (LPARAM) &sysTime);
//这个消息返回后，sysTime的wMinute和wSecond成员的数值是错误的。

if (bResult)
refTime = CTime(sysTime);

return bResult;
}

解决方法：自己发消息，然后修正sysTime的对应成员。

游戏的竞争特性（游戏设定连载之一）

Panic — Wed, 29 Nov 2006 09:01:00 GMT

游戏的竞争特性（游戏设定连载之一）

作者： Panic 2006年11月29日

这里所说的游戏并不仅限于电脑/电子游戏。

游戏的本质是竞争，每个玩家都可以挑战他的对手，而在一定的实力范围内有获胜的机会。对手可以是其他玩家，机器，自然界或者就是自己。

“掰手腕”是最简单的竞争之一，通过单纯的比拼力量决定胜负。这个游戏年代久远，但是只适合力量接近的玩家互相竞争。

当双方的实力相差比较大的时候，强的一方会以压倒性优势获胜并且可能会让对手受伤。

另一个游戏叫做“掷硬币”。玩家抛出一枚硬币，依靠猜测硬币落地后的正反面来决定胜负。

这个游戏比拼的是“运气”，如果投掷硬币的一方能确保较高的随机性，不同的玩家之间没有明显的判断胜负的依据。

这是两个极端的情况，最终的胜负完全依靠实力决定，或者完全依靠运气决定。（有时候运气也是一种实力）

一般的游戏，通常特性介于这两个极端之间，玩家同时受自身实力和运气两个因素的影响。这两个因素所占的比例就决定了一个游戏的竞争特性。

实力因素可以依靠玩家的主观方式改变，通过进行更多的尝试和训练，增加投入，都可以有效提升自身的实力。而运气因素是不可预知而且难以捉摸的。

对于一个游戏，实力因素会导致两个结果，一个是玩家为了提升实力，增加更多的投入到游戏中，游戏黏着度会因此而提升；另一方面，如果这个实力提升过程过于繁琐和无聊，玩家会失去兴趣。

运气因素则起到不同的作用，由于玩家会因为运气好而战胜比自己强的对手，这会吸引更多的玩家进行尝试，但是实力强的玩家也会因为运气不好而被实力弱的对手击败，从而失去游戏乐趣。

最普及的游戏恐怕就是扑克牌和麻将了，他们的长盛不衰表明在实力和运气这两个因素上，达到了比较恰当的比例。

对于扑克游戏（比如80分）来说，一个初学者战胜一个高手的概率是相当高的，经常有人感叹“牌艺差的运气好”，这表明在扑克游戏中，运气因素占据了比较大的比例。

尽管这两个因素难以量化，但是还是可以简单的估计他们所占的比例。

估算这个比例的方法如下：

在完全运气的因素下，双方获胜的几率都是50%，而实力因素则导致强的一方以接近100%的概率获胜。

那么两个实力悬殊的对手，假设实际的竞争中强者获胜的概率是x，那么当x = 100%的时候表明游戏中实力因素占100%，而x = 50%的时候表明运气因素占100%。

x介于这两个数值之间的时候（如果x < 50%，表明对实力的评判依据有问题，或者采样数量不足），运用线性拟合的方式得到实力因素在游戏中占据的比例是(x-50%)*2

这个比例并不准确，我们使用这个公式先进行初步的分析。

使用这个公式，玩家之间胜率和实力对比的曲线如图中蓝色曲线所示：

A1点就是一个新手挑战高水平玩家的胜率。

图中的胜率曲线必定过点B，这表明双方实力相同的时候，任何游戏中，双方的胜率都是50%，即只受运气因素影响。

同时曲线自身关于B点旋转对称，也就是说当竞争双方互换角色的时候，胜率也刚好互换。

D点是一个额外的参数，表明玩家在游戏中可以容忍的最小胜率，玩家实力从0进阶到C1（这个实力进阶，可以以玩家选定固定实力的对手，而提升自身实力来实现，也可以通过选择实力更弱的玩家来实现--b）的过程，就是游戏的上手过程。

现在回来分析最初的两个游戏，首先是掰手腕，在图中用紫色曲线表示。

这个游戏很特别，当两个玩家实力稍微拉开，则结果就很明确了，实力悬殊的玩家，弱的一方几乎没有获胜的可能性。同时玩家实力要从0进阶到C2才有可能完成上手过程，这个过程可能会相当漫长。

掷硬币则刚好相反，如图中红色曲线所示，图中可以看出玩家的胜率和实力几乎没有关系，而且初始胜率A3已经在D点之上了，表示这个游戏不需要一个上手过程。

尽管在曲线AB段可以有各种不同的形式，但是简洁起见，我们还是只把A点位置，和曲线在B点的斜率作为两个关键的参数来分析一个游戏的特性。

A点位置的高低决定了游戏的新手起始胜率，这个数值高有利于吸引新手加入，因为可以有比较高的几率获得胜利，同时也会增加高水平玩家离开的可能性。

B点的斜率决定了游戏是运气主导还是实力主导，斜率越接近0，则运气的比重越大。接近1则两者参半，接近无穷则为实力主导。

同时，运气主导的游戏一般而言上手难度低，而实力主导的游戏上手难度会高一些。

当设计一个游戏的时候，在竞争方式上选择一个实力和运气的比例是很重要的，过分强调实力的游戏会在上手阶段遭遇障碍，而过分强调运气的游戏则会潜在引发资深玩家流失。

专业的竞技类游戏，比如棋类，球类，田径等都是实力主导的，运气成分很低，所以新手几乎没有可能战胜专业的玩家。而一些普及的游戏，比如麻将，升级一类则是运气主导。

游戏的不同阶段可以采用不同的控制方法，使得这两个因素总是保持在一个相对理想的状态，不过这会导致设定的复杂度增加。

除了通过控制运气比例来提高初始胜率之外，也可以在游戏规则上对实力悬殊的玩家之间竞争做一些限制，比如围棋的让子等等。

在一个严谨并且有比较明确的实力界定方法的游戏中，这种限制不失为一种好的方法。但是多数游戏面对的是形色各异的玩家，除了实力难以界定之外，游戏中的一方或者双方无法按照规则进行限制也是很常见的事情。

发布一个speedsim源代码

Panic — Wed, 29 Nov 2006 02:13:00 GMT

最近在玩一个网页游戏叫做ogame，详情请到 ogame.org 了解。
ogame简体中文版的网址是
ogame.com.cn

speedsim是ogame的战斗模拟器。
speedsim是一个开源项目，原作者好像是德国人，但是现有的release版对ogame.com.cn的支持不是很好，于是我下载了源代码做了一些修改。
代码和可执行文件下载请
点击这里

今天下午开始，google.com又访问不了了

Panic — Mon, 30 Oct 2006 10:17:00 GMT

但是我用代理访问没有任何问题。
继blogspot.com被再次屏蔽后，google.com难道也面临新一轮的屏蔽？？

我的hosts文件又增加了几条

Panic — Wed, 18 Oct 2006 03:15:00 GMT

如下：
127.0.0.1       doubleclick.net
127.0.0.1       allyes.com
127.0.0.1       atpanel.com
127.0.0.1       atdmt.com
127.0.0.1       suitesmart.com
127.0.0.1       csa.qq.com

说明，除了最后一个csa.qq.com不知是什么用途之外，前面那些无一例外都是广告网站。

这些网站的恶劣之处在于，你根本就不知道何时访问了他们，但是他们却在你的cookie中留下了记录。

从一个小问题衍生的方法－－三进制数

Panic — Wed, 11 Oct 2006 11:02:00 GMT

从一个小问题衍生的方法－－三进制数

作者： Panic 2006年10月11日

有一个很久以前（可能有数百年）的问题，是这样：

一个重40磅的砝码，不小心摔成了4块，结果这4块刚好都是整数，而且可以用天平称量1～40以内的任何重量。请问这4块的重量分别是多少。

问题很好分析，天平的特性是，砝码可以放置在两边。也就是说，一个1磅的砝码，可以放在右侧作为砝码，也可以放在左侧作为称量物，放在左侧则最终的称量结果要减去砝码重量。

我们现在考虑只有两个砝码的情况，其中一个砝码是1磅，另外一个假设是2磅。那么称量情况是这样：

1磅砝码    2磅砝码      称量的重量
右侧       右侧         3磅
不放       右侧         2磅
右侧       不放         1磅
左侧       右侧         1磅

从这个表可以看出，当大的砝码是2磅的时候，砝码分置两侧，并不能得到一个新的称量结果，所以大的砝码至少应该有3磅，结果变成：

1磅砝码    3磅砝码      称量的重量
右侧       右侧         4磅
不放       右侧         3磅
右侧       不放         1磅
左侧       右侧         2磅

两颗砝码，可以称量4种重量。用大于3磅的砝码也可以称量4种重量，但是那样的话结果就不连续了。

现在把这两个砝码作为一个组合，加入更大的第三颗砝码，那么为了同样满足砝码分置两侧得到不同结果，第三颗砝码的重量应该是：2×两颗之和+1，也就是9磅。然后利用前两颗的拆分交替，就可以得到1～13的任何重量。

同样的可以轻易计算出第三颗砝码是 13×2+1 = 27磅。

这样，1，3，9，27，4颗砝码组成了一个以3为倍率的等比数列。这4颗砝码可以称量1～40之间的任何整数重量。

回到最初的问题，我们可以抽象为：用4个位，表达至少40个不同的量。而考虑到砝码有放在左侧，右侧和完全不使用三种状态，这其实是个三进制数，一个有4位的三进制数。

4位三进制数能够表达的范围是81，在天平的问题中，称量物放在左侧和右侧可以认为是两种不同的结果（或者说是符号位），而称量物也没有放置（或者说重量为0）也算一种情况，刚好造成81种结果。

这个问题到此就完整的结束了。

之所以会考虑这个问题，是因为我在设计一个单片机电路的时候，无意中利用到单片机口线的三种状态。

三种状态就表达了一个三进制位，这样利用7条口线，就可以表达3^7 = 2187种状态，这个数字已经超过了11bit的二进制位(2048)，利用这个特性可以用更少的口线，实现更多的功能，更有效的利用单片机有限的资源。

旧事重提，反转一个字节的算法讨论

Panic — Wed, 06 Sep 2006 08:17:00 GMT

作者： Panic 2006年9月6日

很久以前发过一个相关的随笔：反转一个字节的算法
以及相关的效率探讨：效率的边界－－几种反转字节算法分析

昨天周星星旧事重提，又引发了对这个简单问题的讨论，相关的东西以前已经讨论了很多了，这里不再重复，只提供两个新的算法：

首先是周星星的新算法：

unsigned char reverse8( unsigned char c )
{
    c = ( c & 0x55 ) << 1 | ( c & 0xAA ) >> 1;
    c = ( c & 0x33 ) << 2 | ( c & 0xCC ) >> 2;
    c = ( c & 0x0F ) << 4 | ( c & 0xF0 ) >> 4;
    return c;
}

经过测试，这是目前在32位环境，除查表法之外的最高效算法。

我也尝试了一下，要超越这个算法的效率的确很难，几经周折也没有能够成功。不过这个过程中，考虑了另外一个算法，需要64位环境的支持，代码如下：

typedef unsigned long  U_INT64;
//64位环境。long应该是64bit长度。
//如果有更适合的类型，替换这个typedef即可。
typedef unsigned char U_INT8;
U_INT8 reverse64( U_INT8 C )
{
    U_INT64 c = C;
    U_INT64 a = 0xF7B3D591E6A2C480;
    U_INT8 result = ( ( a >> ( (c & 0x0F) << 2 ) ) << 4 )
        | ( ( a >> ( (c & 0xF0) >> 2 ) ) & 0x0F );
    return result;
}

这个算法的本质还是查表法，但是利用64bit变量代替了表，利用移位代替了查表过程中的寻址。
理论上这个算法应该有更高的效率，尽管仍然无法超越原始的查表法。

但是因为我没有64位的编译环境和运行环境，所以在此恳请有条件的朋友帮忙测试一下这两个代码在64位环境下的表现，参考的测试代码如下：

typedef unsigned long  U_INT64;
typedef unsigned char U_INT8;
U_INT8 reverse64( U_INT8 C )
{
    U_INT64 c = C;
    U_INT64 a = 0xF7B3D591E6A2C480;
    U_INT8 result = ( ( a >> ( (c & 0x0F) << 2 ) ) << 4 )
        | ( ( a >> ( (c & 0xF0) >> 2 ) ) & 0x0F );
    return result;
}

U_INT8 reverse8( U_INT8 c )
{
    c = ( c & 0x55 ) << 1 | ( c & 0xAA ) >> 1;
    c = ( c & 0x33 ) << 2 | ( c & 0xCC ) >> 2;
    c = ( c & 0x0F ) << 4 | ( c & 0xF0 ) >> 4;
    return c;
}

//效率测试代码：
#include <iostream>
using namespace std;
inline U_INT64 GetCycleCount()
{
        __asm RDTSC //获取CPU时间戳
}

int main(int argc, char* argv[])
{
        U_INT64 i = 0,n = 10000;
        U_INT8 c = 0;

        U_INT64 t1 = GetCycleCount();

        for( i = 0; i < n; i++)
                c += reverse64(i);

        U_INT64 t2 = GetCycleCount();

        for( i = 0; i < n; i++)
                c += reverse8(i);

        U_INT64 t3 = GetCycleCount();

        cout << " T1 = " << U_INT64((t2-t1)/n)
                << " T2 = " << U_INT64((t3-t2)/n)
                << " C = " << c         //输出c是为了避免编译器优化。
                << endl;

        return 0;
}

由于对64位环境近乎无知，所以代码可能无法直接编译运行，仅供参考。
谢谢合作:)

警告！抵制中国缘网站的非法行动！

Panic — Thu, 17 Aug 2006 08:31:00 GMT

警告！抵制中国缘网站的非法行动！

作者： Panic 2006年8月17日

很多朋友已经收到了大量来自中国缘的机器人的骚扰，多数都以为这只是像垃圾邮件一样的营销策略，而事实远非如此。

在中国缘的注册页面上，赫然写着“MSN的登陆密码就是你在中国缘登陆密码。”，明确要求用户提供自己的msn密码，这本身就是非法行为。

中国缘获取他人msn用户和密码之后，理论上，就可以利用这个msn做任何事。

迄今为止，被骗取密码的用户可能已经有数十万人。

中国缘目前对于他人msn用户和密码的使用，主要是获取他人的通讯簿，提取联系人信息，为其机器人提供资料。

如果你收到中国缘的msn骚扰，这说明，你的某个或者某些联系人有可能已经上当，你在他们通讯簿中的联系方式已经被中国缘窃取。

请通知你的联系人:

如果有人已经在中国缘注册。请立即修改你的msn登陆密码，确保你的帐号不会被中国缘再次非法利用。

确保中国缘网站利用你的msn做更多坏事之前，尽可能的减少你和你的所有联系人的损失。

为引起更多人关注，暂时放在首页，一周后取消。

忽然很喜欢这首歌《醉清风》

Panic — Tue, 15 Aug 2006 05:04:00 GMT

醉清风
弦子

月色正朦胧
与清风把酒相送
太多的诗颂
醉生梦死也空

和你醉后缠绵
你曾记得
乱了分寸的心动
怎么只有这首歌
会让你轻声合
醉清风

梦境的虚有
琴声一曲相送
还有没有情浓
风花雪月颜容

和你醉后缠绵
你曾记得
乱了分寸的心动
蝴蝶去向无影踪
举杯消愁意正浓
无人宠

是我想得太多

犹如飞蛾扑火那么冲动
最后
还有一盏烛火
燃尽我
曲终人散
谁无过错
我看破

屏蔽解除？Google的妥协或者进展？

Panic — Sun, 13 Aug 2006 17:56:00 GMT

出于众所周知的原因，包括wikipedia在内的许多知名网站都遭到了中国政府的封杀。这已经不是什么秘密了。

Google.com也因为同样的原因被迫启用Google.cn的新域名。并且在搜索结果上赫然显示着：
据当地法律法规和政策，部分搜索结果未予显示。

同时，作为Google旗下的博客空间提供者，blogspot.com也被用一种搞笑的方式屏蔽了，首页可以正常显示，但是所有注册者的二级域名都被屏蔽。

我昨天却忽然发现，blogspot可以正常使用了，二级域名的屏蔽解除了！

这是政府的屏蔽名单上极其罕见的删除纪录，出现这个结果，不知道是Google作出的再次妥协，还是在和政府的谈判中取得了一些进展呢？

事实究竟如何尚未可知，不过想申请博客的朋友现在又多了一个选择了，也算是件好事情。

blogspot首页连接是http://www.blogger.com/
即使你访问www.blogspot.com，最终也会跳转到这个看似不相关的页面的。

[歌词欣赏]I Could Be The One

Panic — Sat, 12 Aug 2006 16:18:00 GMT

I Could Be The One

I could be your sea of sand
I could be your warmth of desire
I could be your prayer of hope
I could be your gift to everyday

I could be your tide of heaven
I could be a hint of what’s to come
I could be ordinary
I could be the one

I could be your blue eyed angel
I could be the storm before the calm
I could be your secret pleasure
I could be your well wishing well
I could be your breath of life
I could be your European dream
I could be ordinary
I could be the one

Now I would lie here in the darkness
Now I would lie here for all time
Now I would lie here watching over you
Comfort you
Sing to you

I could be your worry partner
I could be your socialite
I could be your green eyed monster
I could be your force of light
I could be your temple garden
I could be your tender hearted child
I could be ordinary
I could be the one

Now I would lie here in the darkness
Now I would lie here for all time
Now I would lie here watching over you
Comfort you
Sing to you

Will I ever change the journey
Will the hushed tones disappear
Oh little Rita
Let me hold you
Oh little Rita
Let me love you

I could be your leafy island
I could be your thunder in the clouds
I could be your dark enclosure
I could be your romantic soul
I could be your small beginning
I could be your suit in universe
I could be ordinary
I could be the one

I could be ordinary
I could be the one

笔记本，据说是戴尔的产品。。

Panic — Wed, 02 Aug 2006 07:22:00 GMT

关于火影忍者的一些疑问和分析

Panic — Mon, 31 Jul 2006 20:58:00 GMT

关于火影忍者的一些疑问和分析

作者： Panic 2006年8月1日

火影忍者317话发布，有一些东西随便写写。

1，鸣人是不是人柱力？

从故事情节来看，包括鸣人自己，都是肯定鸣人是人柱力的。但是仔细分析，事实却并非如此。

8只尾兽都能够被封印为人柱力，而且似乎都不是木叶村的忍者封印的，这说明把尾兽封印为人柱力需要的忍术并不是专有的特别忍术，而人柱力我爱罗由千代封印，千代也不需要付出生命代价。

4代封印九尾用的忍术无疑不是专门封印尾兽为人柱力的，作为最强的忍者村，木叶村，木叶最天才的火影，4代，没理由不会一个其他村子似乎有不少人会，而无须付出生命代价的尾兽封印术。

为什么千代能平安封印1尾而4代就得拼命才能封印9尾？除了9尾自身的强大之外，还有一个原因可能就是其查克拉的性质。小樱曾经被9尾的查克拉伤害，是在为鸣人施展治疗术的时候，但是我爱罗同样有过受伤的经历，却没有他人受伤的情节，可见9尾的查克拉不是那么容易控制的。

再有一个例子，我爱罗启动一尾能力的时候，并没有人觉察另外一种查克拉的出现，可见人柱力的查克拉和尾兽应该具有相同的性质，而鸣人每次使用9尾的查克拉，就会有另一种查克拉，也就是9尾的查克拉出现，说明鸣人作为封印体，和人柱力是有很大不同的。

鸣人的身体上有封印9尾的印，这个已经多次看到，但是我爱罗身上的封印，似乎没有出现过。

由此可见，鸣人不是人柱力，或者说，不是“普通”的人柱力，而9尾也不是一只很适合做人柱力的尾兽。

2，鸣人能够压抑和抵抗9尾查克拉的原因？

9尾的查克拉不但强大，而且还会赋予“容器”一些特殊的能力，比如快速恢复能力。一尾的查克拉不具备这种能力。而9尾最特别的是他的查克拉会直接伤害接触它的人，这就导致了它不能为普通人所用。

那么鸣人是依靠什么力量克制9尾查克拉伤害的呢？至今仍然没有说明。也许是某种精神力，但是无疑的，这种能力是与生俱来的，就像血继一样，否则鸣人首次引发9尾的查克拉恐怕就小命不保了。

这种能力可能就是作者安排的鸣人成为火影的根本能力。

3，封印9尾的术，为什么没能把9尾彻底消灭掉？

按照3代的说法，灵魂被拉出后为死神所食，而没了灵魂的肉体就会像大蛇丸的秽土转生一样完全死去，或者像他的双手一样失去功能。

但是9尾似乎既没到死神的肚子里，也没有完全死去，而是随时可以靠封印之书的某些忍术释放出来。

难道9尾没有灵魂么？如果没有，那这个以“拉出灵魂”为基础的忍术就对其完全无效，反之9尾就不能继续存在。这一点也没有很明确的说明。而且4代如何把9尾封印在鸣人体内也是个迷。

因为没人会背着婴儿和9尾作战，而鸣人父母都没有，封印的时候既然是刚出生，母亲至少应该露面一下啊。。。而且4代怎么能立刻得知鸣人拥有抵抗9尾查克拉的能力呢？这也引发了下一个问题。

4，鸣人的父母是谁？

火影至今，所有的异常能力者，只有3类：人柱力，血继传人，天才。当然，有些人兼有多种。

鸣人对于9尾查克拉的抵抗能力，无疑是他人不具备的特殊能力，这个能力不是“人柱力”的能力，因为这因果倒置，也不是血继，因为漫画没有提（当然也不排除鸣人是某稀有血继的传人）。那结果只能是天才。

这种天才，木叶有几个例子，首推卡卡西，虽然没有宇智波的血继，同样可以承受写轮眼，并且可以开万花筒，这种天才来自白牙的遗传。还有4代本人，也没有血继，但是却可以成为几乎是最强的火影。由此可以推断，鸣人也拥有某种遗传，这种遗传使得鸣人天生就是9尾的容器。

那么，结论也许应该这样：鸣人的双亲也是天才忍者，而且在体质上，本身就是为9尾准备的容器。极有可能是像大和一样的试验品，但是他们都是未完成状态，他们的后代鸣人是唯一的完成品。

5，4代封印9尾，而让9尾的查克拉可以为鸣人所用，究竟是为了什么？

首先4代明白9尾是不死的。因为死神也无法奈何它，这在问题3中已经有说明。这也暗示了即使鸣人死掉，9尾也有可能不死。如果杀死鸣人就可以干掉9尾，这个上古神兽未免太冤枉了，而且从晓的成员的能力看，要和人柱力对抗，并非不可完成的任务，杀死人柱力就能杀死尾兽的话，那尾兽应该不会全部存活至今，毕竟人柱力是历史上许多战争的参与者，没理由强的不可战胜。既然尾兽还没有死去的先例，凭什么说人柱力死去，尾兽就一定会跟着死去呢？况且鸣人也不是通常的人柱力。

既然9尾不死，那人柱力死去的唯一后果，就是尾兽被释放。释放的尾兽和人柱力不同，不是那么容易对抗的，基本上都要超级忍者拼死才能封印它，仅仅封印就要拼死了，靠实力击败简直是不可能的。

换句话说，如果鸣人死了，9尾就会被释放，这样一来，现存的忍者是否有人有能力抵抗9尾，就是个大问题了。虽然3代也会那个忍术，但是全盛时期的三代，也许能封印住9尾，9尾出现的时候，4代几乎是全盛，3代已经老了。到了后来，连对付大蛇丸都不能得心应手，更不用说9尾了。

这样一来，4代的意图就很明显了，让9尾为鸣人所用，就是为了让鸣人有足够的实力不被杀死！

而这也从另外一个方面验证了鸣人的身世，一个作为9尾容器而被“制造”出来的悲剧家庭的幸运后裔。这也印证了“晓”的某些行为。

6，“晓”的古怪行为。

首先是抓鸣人的时机。鼬虽然是佐助的哥哥，但是作为暗部的一员，并且拥有万花筒写轮眼的能力，没理由不知道9尾在鸣人身体里面。封印9尾的时候，鸣人刚出生，佐助也差不多还不懂事，但是鼬应该知道这个事情。所以晓从鼬一加入，就得知9尾下落，同时也是派鼬去收集的。这个应该，没有太大疑问。但是明明可以早下手，为何要一直拖呢？

其次是对待其他人柱力的态度，似乎都是两人组就去搞定了，而且其中一人还懒得出手。人柱力有这么弱么？

再次是尾兽捕捉的时间和顺序。晓用了很长时间来准备，积蓄的力量足以和人柱力对抗才开始行动。捕捉也是从最弱的开始，而9尾则一直在拖，每次都无所谓的样子。

答案就是千代的话，要创造新的人柱力，需要能和尾兽抗衡的力量。晓最终的目的，无疑是强大的不可思议的9尾，但是要和9尾抗衡太难了，历史上只有4代火影做过，但是4代付出了生命代价，晓似乎无法在无阵亡的前提下做到，即使是有阵亡，恐怕也未必能成功，这也再次印证了4代的强。

所以晓的目的就很单纯了，用其他尾兽的人柱力，作为对抗9尾的力量。所以在其他8尾收集齐之前，得到9尾也是没意义的。而一旦8尾都到手，想阻止他们得到9尾也几乎是不可能的。

同时，和鸣人的身世相关的，要用9尾做人柱力没那么简单，需要一个能承受9尾查克拉的容器。这个容器没那么好搞，就像大蛇丸的转生一样，也需要3年甚至更多的培养时间。一尾已经用过3个容器，但是迄今为止成功容纳9尾的容器就只有鸣人一个。

所以晓要做的最重要的事情就是培养能容纳9尾的容器，然后用其他8尾（根据神话，9尾可以对抗其他8尾的联合攻击）作为和9尾抗衡的力量，把9尾制造为新的人柱力。这个人柱力几乎是无敌的。

这就是晓的目的。晓的目的也引起了情节的进一步发展。

7，晓的进一步行动？

从神话看，9尾可以单独对抗其他8尾的联合攻击。而为了体现9尾的强，晓应该有办法收集到除9尾之外的其他全部尾兽，这个收集过程就是下一步情节发展的动力。

木叶和其他忍者村的目的，无疑就是阻止这个过程。但是毫无疑问，为了突现9尾的强，所有这些阻止都是无意义的，这些抵抗活动多半会以失败告终。虽然可能有个别尾兽没有被晓收集，但是实力仅次于9尾的8尾，必然是晓的囊中之物。

接下来就要上演神话中的情节，9尾大战8尾，神兽级别的战斗！

8，鸣人的觉醒！

事情没那么简单，如果只是9尾战胜了8尾，鸣人不就太没面子了么？既然鸣人有克制9尾的能力（有时候这种克制就是一种强，就像初代），鸣人也能够克制其他尾兽，毕竟是最强尾兽的容器嘛。

于是在9尾大战其他8尾（都是人柱力）的过程中，鸣人的能力觉醒，压抑住9尾，同时也压制住了其他的人柱力。

至此鸣人的实力已经完美的超越所有历代火影了，成为火影也是顺理成章的事情了，毕竟纲手不喜欢当火影，自来也又坚决不干。但是以鸣人的个性，当火影可不是舒服的差使。所以鸣人的最终结局不会以火影为终，估计会在得到火影称号的同时或者稍候不久就让给其他人，还是继续他的拉面生活去了。

9，下代火影的人选。

既然鸣人不当火影，自然有人要顶上来。备用的人选也很多：

佐助，可能性1%，作为男二号，拥有几乎完美的忍者才能，不过个性不太适合，而且从鸣人手里得到火影也太没面子了。
小樱。可能性1%，女一号，可能性不大，和纲手一样的医疗忍者，不应该第二次出任。
木叶丸，可能性0%，不可能的，还是小孩子呢！太容易就升级了，不成了七龙珠了么？

因为可能性为0的人太多，不一一介绍，只选几个说说。

上忍之中，卡卡西和阿施玛，还有凯，都几乎是不可能的几率不超过1%，还有那个木叶丸的家庭教师,0%。红存在5%可能性。大和也有3%左右。

暗部和团藏等近乎隐藏的人物中可能有更高几率的人选。这些人选会在稍后的故事中展现实力。

中忍，鹿丸好像是没可能的啦，太没干劲了。

其他的下忍，象牙，丁次一类的机会也不大，倒是日向的宁次挺有机会，论实力有实力，要智商有智商，虽然可能不是绝顶的高，但是还是可以的。

从历史看，火影都是忠厚老实，或者博学睿智的人，所以新的火影也不适合打破这个规则。

10，情节的复杂性

从317话开始，接下来的情节就复杂化了。因为作者在前面埋下的各种伏笔，还有相关的隐藏情节要逐渐揭开。这样会引起剧情的“颠簸”，一方面是鸣人前进路上波澜起伏，另一方面各种回忆，往事穿插不断。

同时各种没有详细设定的细节也要找到完美的结局。比如鸣人如何压制9大尾兽，又不能杀死，又不能简单的封印（会引起现存人柱力死亡），也不能作成新的人柱力，究竟怎么处理才是妥当的呢？

小樱的爱情路线也要给个说法，究竟是鸣人路线还是佐助路线。

写轮眼的诅咒命运要揭开，究竟和9尾有什么关系。佐助的悲剧也要画句号了，毕竟是新人中的第一帅哥，不能一辈子就为了复仇。

单上面这些内容，每个都够折腾了。

就算不折腾这些远期目标，光是晓的收集行动就很有的玩。

11，另外一些值得说明的东西

佐助的出走，虽然名义上是追求大蛇丸的力量，但是这出走的直接原因恐怕还是自己的老师卡卡西教授的千鸟在和鸣人的螺旋丸的对比中呈现劣势，而鸣人超常的通灵召唤又令佐助大受打击。

借助了大蛇丸的力量，佐助在终结之谷击败鸣人，也坚定了他追求大蛇丸力量的决心。

但是这是否意味着他会自愿把身体给大蛇丸用呢？答案是否定的。佐助和鼬，在实力上的根本差异在于鼬的万花筒，其他的差距都可以通过修行弥补，唯独那个万花筒没办法。佐助不愿用鼬的方式说明了佐助心中的善。虽然口口声声说要杀鼬，但是我估计佐助还做不到。他只是要向鼬证实自己的实力。即使他有能力杀鼬了，估计也不会真的下手，但是鼬有可能主动送死而死在佐助手上。

所以佐助归顺大蛇丸，还不如说是利用大蛇丸，佐助这么有个性的人物，怎么能放弃亲自和鼬决斗的机会呢？怎么能放弃和鸣人对决的机会呢？而且拥有血继的他，怎么可能会真的相信大蛇丸的力量？相信大蛇丸的力量只是暂时的，因为比大蛇丸强的人，就是宇智波一族的鼬啊，鼬能超越大蛇丸，他没理由不行的，而且他还要超越鼬，甚至超越鸣人。估计作者会给佐助机会局部超越鸣人。

理论上大蛇丸已经是不死之身了，所以他可能会活的久一些。他的身世也是未知数，三忍只有纲手是有来历的，自来也似乎也应该说明下了。

作为三忍的徒弟，只有鸣人继承了文太作为通灵兽，小樱和佐助没理由空手的。新的召唤兽也登场一下吧~小樱召唤鼻涕虫也还勉强，但是佐助召唤万蛇就太夸张了，佐助的fans会郁闷的。

尾兽的不死也可以解释前面9尾要佐助不要杀鸣人的情节，因为尾兽自身不会死，所以没有哀求的成分，9尾说这话也就是告诉佐助，鸣人对你很重要，你那个该死的诅咒，要依靠鸣人来破解。而9尾是怎么知道这个的呢？他以前也没见过鸣人啊？原因可能有两个，一个是9尾能感受到鸣人的体质，知道鸣人的潜力，另外一个就是9尾见过或者了解过鸣人的双亲，知道他们和宇智波一族的渊源。

还有个奇怪问题，日向是木叶最强的一族，血继是白眼，而宇智波是最强的一族（全球最强？），血继是写轮眼，同样是使用眼睛的血继，他们之间应该有很多竞争和冲突才对。另外木叶最强的忍者火影居然没有一个是最强的日向一族的后代，这个似乎有点说不过去。

白眼和写轮眼的竞争其实是白眼赢了，因为写轮眼副作用很大，而白眼似乎没什么副作用，所以写轮眼的拥有者不会频繁使用，但是白眼却相反。这可能是日向和宇智波之间关系寡淡的原因。日向一族不能昌盛似乎是因为那个该死的宗家家规。

12，总结

以上都是无聊瞎掰的，本人不是火影fans，但是漫画几乎看了全部，动画片也看了不少，无意间看到火影的一些论坛有众多分析高手，也跟着起哄凑个热闹^_^

奇怪的代码？

Panic — Fri, 28 Jul 2006 09:11:00 GMT

作者： Panic 2006年7月28日

第一个：

int i = 0;
i.~i();

第二个：

int i = 0; int j = 0;
i.~j();

第三个：

~int();

第四个：

~0();

第五个：

0()()()()()();

这些都是合法的代码么？^_^

一个很巧妙的错误，欺骗编译器

Panic — Thu, 27 Jul 2006 07:21:00 GMT

一个很巧妙的错误，欺骗编译器。

作者： Panic 2006年7月27日

很久没碰到什么有趣的问题了，今天看到一个，特写随笔一篇以作留念:P

问题的来源：

一种让另外的类对本类成员只读，本类对本类成员可读写的方法。 [所有相关帖子]

例子
//a.h
class a
{
public:
void test();
#ifndef A_CPP
const
#endif
int b;
};

//a.cpp
#define A_CPP
#include "a.h"
#undef A_CPP

void a::test
{
b = 12; //可以写
}

//b.cpp
#include "a.h"
void b()
{
a _a;
_a.b = 12;//编译错误不可写
}
书童 xulingfv 发表于 2006-7-27 10:46:09

周星星的代码：

// a.hpp
struct foo
{
    foo();
#ifdef SOMETHING
    int a;
#endif
    int b;
};

// a.cpp
#define SOMETHING
#include "a.hpp"
#undef SOMETHING
foo::foo()
{
a = 1;
b = 2;
}

// main.cpp
#include "a.hpp"
#include <iostream>
int main()
{
foo test; // 理论上讲，a.cpp和main.cpp中的foo定义不同，是不同的类型，所以应当报foo()未实现，但实际上却正确
std::cout << test.b << std::endl; // 输出1
}

上面的代码，有兴趣的可以试试，这里只说明问题：

首先澄清几件事：

1，对编译器来说，一个函数定义在什么地方并不重要，无论foo::foo()定义在哪里，它都是foo类型的构造函数。

2，对链接器来说，区分不同函数（或者类型）的唯一方法是这个函数最后生成的符号名字，如果存在两个相同的符号，就会报重定义的错，而反之，无论这个符号来自何处，链接器都会把这个符号和对应的函数代码链接在一起。

3，对同一个编译单元，或者说，同一个.C/.CPP文件，里面的每个定义只会生成一份OBJ代码，模板则会为每个类型生成一份代码－如果可能的话。

这几件事情澄清之后，其实上面的代码就没有任何问题了，简单的说明一下：

第一段代码：

a.cpp和b.cpp中的class a，毫无疑问并非同一个类型，但是利用#define和#undefine，强制生成了完全相同的类型名字。

为了区分，这里把a.cpp中的class a称作a1，b.cpp中的称作a2。

当编译a.cpp的时候，编译器使用的是含有int b的定义，这时候void a::test是void a1::test。

而编译b.cpp的时候使用的是含有const int b的定义这时候a _a;其实是a2 _a;

这两个类型中因为只存在一个成员是否是const的差别，一般情况下具有相同的内存布局，所以成员函数（包括构造函数）的调用不会出现太大的问题，但是实际上，这是两套不同的类型生硬的捆绑在一起的结果。

假如通过a2来调用test函数，由于编译器为a1生成的void a1::test和void a2::test的符号完全一致，于是链接器很自然的把void a1::test嫁接在了a2的调用点上，造成了a1和a2难以区分的假象。

第二段代码：

其实和第一段完全一样，foo::foo()作为foo1版本的构造函数，它的链接符号和int main()中的foo2版本完全一样，导致链接器错误的把这个函数嫁接在了foo2的构造过程中。

不过这个例子中，foo1和foo2的内存布局不同，所以由此引发的内存越界访问的错误可以通过一个简单的方法测试：

写如下代码：

#include "a.hpp"
#include <iostream>
int main()
{
    int a;
    foo test;
    int b;
    std::cout << a << std::endl; // 输出a
    std::cout << test.b << std::endl; // 输出1
    std::cout << b << std::endl; // 输出b
}

在一般的实现中a和b其中之一会输出数值2，也就是foo::foo()中的第二个赋值。

值得注意的是，在debug版本下这种对编译器的欺骗很可能不会带来实质性的错误，但是经由release版本的优化之后，两种类型定义的差别会显著增大，一般会导致运行期错误。

事实上这种错误以前就出现过，在使用了第三方代码库的项目中，项目自身定义了某个函数而忘记实现，恰好库中也有一个同名但功能却大相径庭的函数，链接器忠实的把错误的函数链接在了用户的调用点，引起一个难以发现和修改的bug。

我们在代码中使用各种命名规范区分名称，使用namespace隔离潜在同名空间，从而最大程度的避免同名函数/类型的问题。而以这种错误为技巧来制造看似有效的手法，会给工程留下隐患。

写到这里，我忽然对早上和释雪探讨的一个问题有了一些认识，问题是这样的：

一个模板
//a.h
template<class T>
class Test
{
};

假如在两个CPP文件中分别以相同的模板参数做了不同的特化（比如写了两个Test<int>的特化代码），会冲突么？答案是不会。而实际使用的特化版本以最先编译的那个单元为准。

要解释这个问题，需要明白另外一件事，就是“模板的代码，在使用的地方必须是可见的”这条规则。

C++ ISO中并没有规定这种行为，那么是什么导致了编译器的这种限制呢？原因就是每个编译单元都不依赖其他单元完成编译，这样一来模板代码就找不到形成OBJ的时机。

具体来说是这样：

假如模板的所有实现代码都存在于某个CPP文件中，当这个CPP文件作为一个编译单元进行解析的时候，因为不知道模板究竟对哪些模板参数进行了实例化，所以也就无从生成OBJ文件。而对所有类型都生成实例在理论上是不可能的。

而在使用了模板的地方，因为不知道模板的实际代码在哪里，也无从为模板生成OBJ文件。这样一来，模板的代码就完全没办法实现了。

于是实际的编译器，应该是采取了这种策略，当编译到使用某个模板的时候，先检查这个模板实例化后生成的符号是否已经存在，如果不存在就根据代码生成实例，并且把符号记录，反之就直接关联已经存在的符号。

由于编译单元的编译顺序完全是由使用者人为控制的，所以编译器自身无法获取首次实例化的时机，那唯一可行的办法就是在每个调用的地方都使得模板代码可见，这样一来无论哪个编译单元首先进行实例化，都可以顺利生成实例。

这条规则有一个隐患是，规则要求的只是可见性，并不要求“同一性”，换句话说，你可以把模板代码写在头文件中，然后所有的使用者都去包含它。也可以把模板的实现代码写在每一个使用它的地方。

如果你使用后一种方法，写在每个文件中的实现代码，可以是各不相同的，能够生成实例的那个版本是首先编译的那个版本。也就是说，程序最终生成的代码，是和编译顺序相关的。

写了这么多，也不知道问题有没有说清楚。

有兴趣的朋友可以写个代码测试下，不同的编译器也许还有不同的细节差异。

GetDC使用中容易忽视的bug

Panic — Thu, 20 Jul 2006 06:10:00 GMT

GetDC使用中容易忽视的bug

written by Panic 2006/07/20

msdn中已经有详细说明：

The GetDC function retrieves a common, class, or private DC depending on the class style specified for the specified window. For common DCs, GetDC assigns default attributes to the DC each time it is retrieved. For class and private DCs, GetDC leaves the previously assigned attributes unchanged.

After painting with a common DC, the ReleaseDC function must be called to release the DC. Class and private DCs do not have to be released. The number of DCs is limited only by available memory.

关键是这一句：

After painting with a common DC, the ReleaseDC function must be called to release the DC.

但是由于GetDC直接返回一个指向CDC的指针(SDK中，返回的是一个HDC句柄)，所以可以用这种形式的调用：

GetDC()->XXXXXX

但是这样一来，由于返回值没有保存，就无法进行ReleaseDC的调用了，由此会引起一个GDI资源泄漏。表现就是程序使用的GDI资源数量增加1。

在Win2k下，每个进程的可用GDI资源总数为10000，所以一般情况下这种泄漏不会引起什么实际的问题。但是，当程序需要频繁刷新，或者构造大量GDI对象的时候，就会面临GDI资源耗尽的问题。

GDI资源耗尽，导致的后果是无法创建新的GDI对象，但是在MFC中，GDI对象的构造函数不会因此而抛出异常（因为许多时候，实际的GDI对象不是在构造函数中建立的）。

由于GDI对象创建失败是很罕见的情况，而且失败了，也几乎没什么挽救手段，所以相当多的代码都不检测GDI对象创建是否成功。

以上这些同时存在于一个工程中的时候，就会引起一个难以觉察的bug，他的表现是GDI出现异常显示或者其他错误，直接原因是GDI对象创建失败，本质原因是没有对GetDC得到的返回值做ReleaseDC的调用，导致GDi资源耗尽。

也许其他的Get函数也有类似的问题。

虽然msdn说：The number of DCs is limited only by available memory.但是由于GDI资源总数的限制，这句话并没有实际意义。

我在msdn上没找到GDI对象总数限制的内容，10000个是我在win2kpro sp4上实测的结果。

有可能是关于那只流浪猫的最后一篇随笔了。

Panic — Mon, 17 Jul 2006 15:19:00 GMT

今天晚上下班回家，那之小猫还在我门外，我打开门，它就跟着我走了进来，家里又没有东西给它吃了，我出门买了个炸鱼片。

发现我的皮肤对猫有轻微的过敏，看来不太可能长期养它了。我到厦门本地的户外论坛发了个帖子，找一个好心人来收养它好了。

流浪猫的难题。。。

Panic — Mon, 17 Jul 2006 02:05:00 GMT

昨天晚上，大约11点的时候，又听见猫在外面叫。我走出去，发现它躲在走廊的角落里，一副可怜兮兮的样子，只好又把它领进屋里。

去食杂店买了个鱼片给它当夜宵，我自己也买了个八宝粥。回来之后，把鱼片给它，自己吃八宝粥。但是小猫用一种很期待的眼神看着我，确切的说是看着我手上的八宝粥--b于是分了一点给它，它居然吃得很开心得样子。。。

吃过东西，小猫似乎总喜欢用爪子挠痒，于是烧了点温水，打算给它洗个澡。

猫很怕水么？很用力的拼命往脸盆外面跑，非常不情愿。

勉强洗完了澡，找了个旧毛巾给它擦擦，它跑到一边开始拼命舔自己的毛。

我躺在床上看书想等它安静了就睡觉，没想到它突然就跳到床上，坐在床头上继续舔它的毛。

我把它拎起来放到地上，不一会它又跳上来。。真是难缠。。

等它完成舔毛工作，很自觉的跳下床，跑到床底它一直呆的角落里面去了，我关了灯睡觉了。

今天早上醒来的时候，发现它趴在床上对这我看--b

为了防止这家伙白天趁我不在的时候，在我的房间里面折腾，我还是在出门上班的时候，把它放在门口，今晚我下班回来的时候，看看这个小家伙是不是还在:P

不过看来这只猫独立生活的能力很差，可能白天也没办法自己找吃的，估计又得饿一天肚子了，如果它晚上还在的话，我还是尽量让它呆在屋里好了。。

为什么受伤的总是我~

Panic — Sun, 16 Jul 2006 11:46:00 GMT

那只小猫，居然毫无征兆的，就咬了我一下。。。。

虽然我感觉到是很轻的，并不带有伤害的意味，但是猫的牙齿太锋利了，4个红色的牙印，立刻就显现出来。

无奈，只好去医院打狂犬疫苗。

本来打算收留这只流浪猫的，现在看来还是算了。。

我把小猫放在门口，如果它要走，就让它去好了，如果它不走，那我还是会请它吃炸鸡翅的。

拣了一只流浪猫~

Panic — Sat, 15 Jul 2006 23:36:00 GMT

昨天晚上出去吃东西，走着走着，忽然听到猫叫。回头仔细找，发现路边树丛中有一只小猫，我走过去，它就躲起来，我离开了，它又出来。

厦门的流浪猫非常多，估计有数千只，这些猫最初是家养，后来离家或者走失，就成了流浪猫。

流浪猫每天靠捡拾垃圾堆中的食物为生，白天躲在隐蔽处，晚上出来活动，到了繁殖季节，也不忘向爱慕的对象唱情歌。

我吃完东西回来，发现那只猫竟然还在原地。我走过去，这次它没有躲起来，而是呆在那里默默的看着我。

不知道猫的世界里面怎么表达“友好”，我朝它伸出手，它没反映。当我把手收回来的时候，它居然。。。朝我走过来了。。。

弓着背，尾巴翘的很高，似乎很紧张的样子，但是它还是走过来，我尝试用手抚摸它的背，它回头似乎想咬我，但是，又没有。

肯定是连续的大雨把它淋坏了，它身上有些潮湿，从我的手边穿过，它开始围着我转，用身体摩擦我的腿。依稀记得这似乎是猫咪表达友好的动作。总以为猫咪是忘恩负义的动物，没想到一点点的亲近，就会得到友好的回馈，比很多的人类更真诚呢。

我决定把它带回家。把它抱起来，开始往住处走去。

回家之后才发现，竟然没有任何可以喂这只猫咪的东西，于是我又出门，找寻还在卖东西的店铺--夜里接近两点，几乎没什么店铺是开着的了。

终于找到一家卖西式快餐的店，花了3块5买了个炸鸡翅，然后匆忙赶回去。

进门却发现猫咪不见了踪影，仔细找，发现它躲在床底的角落。我实在不知道怎么把它叫出来，只好把床拉开，然后把炸鸡翅放在一张硬纸上面，放在了猫咪的旁边。

几经犹豫之后，猫咪终于开始咬那个鸡翅，虽然鸡翅并不大，但是对这么小的猫咪来说，还是有点难度，而且它似乎不喜欢炸鸡翅那层油油的脆皮。。。

它在吃东西的时候，我去看它，它会朝我张嘴，露出它的尖牙，同时发出“咕咕”的声音，难道是让我不要跟它抢吃的？怕怕。。。

看来它真的是饿坏了，一只鸡翅很快就吃光了，看起来似乎很困倦的样子，我就关灯睡觉了。

打算今天去宠物医院了解下，怎么养这只小猫咪，如果它愿意在我这里常住的话，以后的麻烦事估计还多着呢。

二叉堆的模板代码－－续“关于一道算法题《编写算法，从10亿个浮点数当中，选出其中最大的10000个》”

Panic — Mon, 19 Jun 2006 08:07:00 GMT

作者：Panic 2006年 6月 19日

原话题随笔：关于一道算法题《编写算法，从10亿个浮点数当中，选出其中最大的10000个》

这里是我写的使用二叉堆作为有序容器的代码。

代码的前半部分是二叉堆的实现，这个实现比较简陋，成员函数也不够完整。后面附带测试代码。

代码如下：

#include <vector>
#include <algorithm>
template <class T>
class binary_heap
{
public:
    void push(const T& x)
        {
                size_t index = _array.size();
                size_t index1 = (index - 1)/2;
                _array.push_back(x);
                while( (index>0) && (_array[index] < _array[index1]) )
                {
                        std::swap(_array[index],_array[index1]);
                        index = index1;
                        index1 = (index - 1)/2;
                }
        }

        bool replace_front(const T& x)
        {
                if( x > front() )
                {
                        _array[0] = x;
                        sort_front(0);
                        return true;
                }
                else
                {
                        return false;
                }
        }

        void pop()
        {
                _array[0] = _array.back();
                _array.pop_back();
                sort_front(0);
        }

        const T& front() const
        {
                return _array[0];
        }

        size_t size() const
        {
                return _array.size();
        }

private:
        void sort_front(size_t index)
        {
                size_t index1 = index * 2 + 1;
                size_t index2 = index * 2 + 2;
                 while( index1 < size() )
                 {
                        if( index2 >= size() ) //临界
                         {
                                 if( _array[index] > _array[index1] )
                                 {
                                         std::swap(_array[index],_array[index1]);
                                         index = index1;
                                 }
                                 else break;
                         }
                         else //普通情况
                         {
                                 if( _array[index1] < _array[index2] )
                                 {
                                         if ( _array[index] > _array[index1] )
                                         {
                                                 std::swap(_array[index],_array[index1]);
                                                 index = index1;
                                         }
                                         else break;
                                 }
                                 else
                                 {
                                         if ( _array[index] > _array[index2] )
                                         {
                                                 std::swap(_array[index],_array[index2]);
                                                 index = index2;
                                         }
                                         else break;
                                 }
                         }
                         index1 = index * 2 + 1;
                         index2 = index * 2 + 2;
                 }

        }
        std::vector<T> _array;

};

//测试代码
#include <windows.h>
__int64 getrand()
{
        static __int64 i = 0;
        ++i;
        return i;
}
int main(int argc, char* argv[])
{
        int I = 100000;
        int J = 10000;

        int t = GetTickCount();
        binary_heap<__int64> s;
        while(s.size() < 10000)
                s.push(getrand());
        for( int j = 0; j < J; j++)
                for( int i = 0; i < I; i++)
                {
                        __int64 temp = getrand();
                        s.replace_front(temp);
                }
                t = GetTickCount() - t;
                printf( "Time = %d ms",t);
                return 0;
}

几点说明：

1，一般认为二叉堆用数组存储，其首元素保留，而从下标为1的元素开始会比较自然，这里我直接从0开始，后果是每个计算增加一次加法运算。

2，这个实现直接用给定类型作为数组成员，当此类型是用户自定义类型，并且尺寸较大的时候，swap等操作的效率比较低。可以考虑以间接方式存取。

3，除了push和size之外，其他的成员函数调用都必须满足堆不为空，用户必须自己检测容器当前的size。

4，理论上，用户自定义容器的行为，应该尽量向标准容器靠拢，提供尽量兼容的外部接口，这样的容器就更容易使用标准库中的各种范型算法，从而增加应用效能。这个版本的二叉堆是一个简化版本，详细的，更接近标准容器行为的二叉堆实现，请参考《STL源码剖析》，这本书中给出了足够详细的描述和代码。（个人感觉如果不是为了成为库，或者提供足够的通用性，写得像标准容器实在累--b）

5，关于二叉堆的其他信息，可以参考我的另一篇随笔《[翻译]在A*寻路中使用二叉堆》

VCKBASE一些ID的谜语^_^

Panic — Sun, 18 Jun 2006 23:59:00 GMT

本贴纯属恶搞，如有得罪，还请海涵^^ by Panic

1，freedk进了小黑屋——打一流行歌曲。谜底： [囚鸟]
2，哭鱼逛街———打一词人。谜底： [陆游]
3，小胖兔看孩子——打一影视作品。谜底： [超级奶爸]
4，阿荣——打一影视作品。谜底： [刀锋战士]
5，YangTze & 老梆菜——打一影视作品。谜底： [杨门虎将]
6，玻璃结婚了——打一流行歌曲。谜底： [冲动的惩罚]
7，玻璃跪搓衣板——打一流行歌曲。谜底： [爱的代价]
8，icebreaker旷课——打一影视作品。谜底： [逃学威龙]
9，阿荣拜访YangTze——打一中国古典著作。谜底： [西游记]
10，VCK站长写文章——打一中国历史人物。谜底： [王献之]
11，爱琳结婚了——打二影视作品。谜底： [魔幻新娘，落入敌手]
12，释雪做斑竹——打一影视作品。谜底： [小鬼当家]

选中后面方括号中的内容，即可看到谜底:P

王者归来-巴西提前出线

Panic — Sun, 18 Jun 2006 18:56:00 GMT

89分钟，弗雷德的进球为巴西队锁定胜局。2 :0，巴西提前出线了。

尽管这场比赛中，澳大利亚的发挥非常出色，不断给巴西队的后防线制造压力，而巴西却始终把握着场上的主动权。

在澳大利亚禁区前沿，从容的传球，接应，一切都让人觉得进球是那么合情合理。

虽然我并不是球迷，对各支球队也知之甚少，但是我总感觉，和其他传统强队比起来，巴西队拥有一种霸气，这种霸气使巴西队在绿茵场成为真正的王者。

关于一道算法题《编写算法，从10亿个浮点数当中，选出其中最大的10000个》

Panic — Wed, 14 Jun 2006 08:57:00 GMT

很久以前的题目了，这个题目，google，百度，腾讯都出过类似的。

理论上有两种方法，
一是数据全部排序，时间复杂度一般为O(n * log(n) )，但是考虑到10亿这种数量级不适合全部载入内存，所以实际的算法估计只能采用外排序。这是个算法效率太低，不太实用。

另外一种是用一个有序容器保存10000个数，然后其他的数字依次和容器中的最小数字比较，如果大于容器已有的，就插入容器并删除原先最小的那个，而容器仍旧保持有序。
这个算法的时间复杂度是O(n)，理论上可能已经没有更好的算法了。

在这个前提下，算法之间的差异仅在于容器的选择和一些算法细节优化。

今天无聊，尝试写了一下这个算法。

考虑到生成随机和有序浮点数比较困难，我用了__int64类型做替代。

原始数据的集合采用动态生成，除了节约空间之外也几乎忽略了硬盘等IO时间。

算法的两个极端是：

当所有数据成升序排列的时候，每一个新的数据都会导致容器变化，这时候是算法的最坏情况。

反之成降序排列的时候，每个新数据都不会导致容器变化，这是算法的最好情况。

我写了一个算法，
环境 win2k VC6SP5，AMD2400+ 超频致1.9G 内存512M

最坏情况下，需要三分钟才能完成计算。

我的实现代码请参考
二叉堆的模板代码－－续“关于一道算法题《编写算法，从10亿个浮点数当中，选出其中最大的10000个》”

这里给一个使用std::set的实例代码，效率差一些，不过代码很简洁：

#include <set>
#include <windows.h>
__int64 getrand()
{
        static __int64 i = 0;
        ++i;
        return i;
}
int main(int argc, char* argv[])
{
        int I = 100000;
        int J = 10000;

        int t = GetTickCount();
        std::set<__int64> s;
        while(s.size() < 10000)
                s.insert(getrand());
        for( int j = 0; j < J; j++)
                for( int i = 0; i < I; i++)
                {
                        __int64 temp = getrand();
                        if( temp > *(s.begin()) )
                        {
                                s.insert(temp);
                                if( s.size() > 10000 )
                                        s.erase(s.begin());
                        }
                }

                t = GetTickCount() - t;
                printf( "Time = %d ms",t);
                return 0;
}

输出是：
Time = 452172 ms

忽然发现set得到的结果是错误的，因为set有做唯一性判断，换句话说，当给定的输入中有相同元素的时候，这些元素就被忽略掉了。。

贝特琅奇论（Bertrand paradox）---数学中的诡辩术

Panic — Sun, 11 Jun 2006 11:30:00 GMT

铅笔的blog上载了这样的文章：贝特琅奇论（Bertrand paradox）
基本内容如下：

Bertrand paradox:

在半径为1的圆内随机地取一条弦，问其长度超过圆内接等边三角形的边长的概率是多少？

这个问题很多不同的答案，比如：

答案1 任何弦交圆周两点。不失一般性，先固定其中一点，则弦的另一端只有位于此固定点正对的1/3圆周长的弧内才满足要求，所以概率是1/3

答案2 弦长只与它到圆心的距离有关。因此满足要求的弦和与之垂直的直径的交点到圆心的距离必须大于1/2，而直径长为2，所以概率是1/2

答案3 弦的中心点必须位于半径为1/2的同心圆之内才满足要求。而此圆的面积是大圆面积的1/4，故所求的概率是1/4

这其实是个很典型的诡辩，使用的手法叫做“偷换概念”。

这个问题的核心在于如何“随机取一条弦”。

按照题目的要求，最终概率计算针对的是“随机的弦”，但是弦是一个特殊量，无法用直接的手段定义，于是为了定义这个弦，采用了间接的手法，我们把这个手法叫做映射f，而原始的随机量作为x，我们得到一个弦的表达f(x)。
问题就出在这里，对于“随机”（这里的随机，指的是等概率分布）的x，f(x)并不一定是等概率分布的，换句话说，如果无法证明f是线性影射，那么据此得到的结论无法保证是正确的。

而原命题中，直接用f(x)作为“随机弦”得出结论，其实就是把“随机弦”的概念置换为由随机x产生的影射f(x)。

举另外一个例子：
要考察[0,1]之间的数字，小于0.25的概率。
假设等概[0,1]区间是无法直接定义的（类似“随机弦”），而[-1,1]区间（x所在的区间)是可以定义的（类似前面命题中的圆周两点，圆心距等），这时候从[-1,1]映射到[0,1]的方法有很多种，也就是存在多个f。
我们首先使用一个简单的映射f(x) = abs(x)
根据这个映射的规则，等概[0,1]区间上，小于0.25的数字，概率是25%。这个结论看来是正确的。

当然，也可以使用另外的映射f(x) = (x*x)
这个映射同样能得到一个[0,1]的“随机”区间，但是在这个区间上，你很吃惊的发现，小于0.25的数字的概率高达50%。

如果你觉得选用abs作为映射函数是正确的而使用平方是无稽之谈，你仍然犯下了很遗憾的错误，因为事实上，真正的把[-1,1]以线性方式映射到[0,1]的方式是f(x) = (1+x)/2，这个错误也说明判断一种映射方式是否正确并非一件轻而易举的事情，在一维空间上尚且如此，更何况二维空间呢？

美国人都吃些什么药

Panic — Sun, 21 May 2006 03:38:00 GMT

美国人都吃些什么药

作者： Panic 2006年5月21日

从一个国家的人吃些什么药，可以从一个侧面反映这个国家的人的生活。

中国不在此列，因为在中国，“药品不是馒头”，不是每个人都吃得起的。

下面是美国某药品销售商的畅销排行榜。

1. VIAGRA //大名鼎鼎的“伟哥”
2. CIALIS //号称比伟哥更有效
3. VIAGRA SOFT TABS //SOFT TABS，一种更快见效，药力更持久的药剂形式
4. CIALIS SOFT TABS
5. VALIUM //安定，安眠药
6. XANAX //一种强效安眠药
7. AMBIEN //一种不易上瘾的催眠药
8. MERIDIA //减肥药
9. PROPECIA //一种治疗男性脱发的药品
10. SOMA //女性凝胶护理精华
11. TRAMADOL //镇痛药
12. AMOXICILLIN //阿莫西林,抗菌药
13. ACYCLOVIR //抗传染性疾病药品
14. ATIVAN //一种镇静安眠剂
15. CELEBREX //止痛药
16. GLUCOPHAGE //一种治疗糖尿病的药品
17. LASIX //利尿剂
18. LIPITOR //降胆固醇药
19. PAXIL //抗忧郁药物
20. PENICILLIN //盘尼西林,也就是青霉素
21. PROZAC //氟西丁,抗焦虑药
22. ZOLOFT //舍曲林,抗抑郁药

看了这个清单，你，有何感想？

偶遇大雁

Panic — Fri, 19 May 2006 17:56:00 GMT

昨晚23:30骑单车出发，经会展中心，沿环岛路骑行，抵白城后返回。

在距会展约5公里的地方，忽然发现右前方的海面上空，有一队飞鸟，正和我沿同一方向，顶风向东前进。此时大概0:10分。

仔细观察，发现鸟群排成“人”字形队列，猜测是大雁。

环岛路的路灯照射到大雁翅膀的下方，才使得大雁从黑暗的天空中显露出来。

其时，我的速度大约23公里/小时，雁群和我基本保持同步，就是说雁群顶风飞行的时速也有23公里左右。雁群的飞行高度目测约30~50米，总共8只，由一只领队，其余左2右5，排成不对称的队形。

和雁群同行约10分钟后，雁群开始向北方转向，而我只能沿公路继续向东直行，大雁在夜空中越飞越远，最后消失在黑色的天幕中。

因为没有相机，无法拍摄大雁的照片，这里仅画一个示意图，以作纪念。

同时，我单车的骑行里程突破4000公里，虽然长久以来没怎么骑车，这个数字还是挺鼓舞人心的。

单板机外一篇

Panic — Wed, 26 Apr 2006 15:36:00 GMT

单板机外一篇

作者： Panic 2006年4月26日

今天顺手，多写一篇。

因为最近在研究单板机（请参考我的另一篇随笔《单板机开发手记》），所以这方面的资料看的比较多，结果也很巧，有个家伙居然上门推销一款所谓国内最新的单板机学习板。

这个家伙不知道我刚好研究这方面的东西，我也没多说什么，只是想知道他有什么花样。

首先他说，他的单板机使用basic语言作为开发语言，语法简单上手快，等等。

从个人感觉，basic语言和汇编的操作模式相去甚远，导致的结果就是编译之后的bin体积会相对比较大。

就PC的情况，用C写代码，最终EXE执行体的容量大约比汇编多20%左右。

而basic少有编译器，一般都是解释执行，据小道消息说，basic编译后，体积会比汇编多60%左右。

有人认为，现在单板机发展迅速，容量大一点没关系。

不过个人认为，在PC平台上，开发商销售的只是软件，作为硬件的PC，用户自己会有升级的需求。

而单板机则恰恰相反，硬件和软件是捆绑在一起销售的，如果因为软件原因导致必须使用更大容量，更高频率的芯片，直接的后果就是成本升高，因此多数情况下，节省存储容量的方式对于降低成本增加利润是有百益而无一害的。

所以开发工具的简洁化，如果是以增加硬件成本为代价的话，恐怕难以为那些惟利是图的开发商所接受。

然后他说，我这个学习板，处理键盘输入是用扫描的，8根线就能处理4*4总共16个按键的响应，比别人先进。

据我所知，实际应用中，按键在5个以上的产品，大部分都是用扫描的，除了节省口线之外，也更方便处理一些复杂按键消息，比如长按，组合键等。

把一个已经应用很广泛的技术说成自己的卖点，要么他技术水平差，要么他在骗人，总之买他的产品是不对的。

他又说，用我的开发工具，可以开发机器人，这机器人可以走路可以做俯卧撑(--b)

真是遗憾的很，本人对机器人也很有兴趣，而且也见过工业机器人是如何工作的。对于做某些给定的，固定的动作，机器人的控制电路只需要输出一定的时序给步进电机即可，这个技术几乎没有什么难度。

机器人控制的难点在于对目标的识别（机器视觉&感觉）和对输入信号的智能响应（机器学习&AI系统），以及自身状态反馈和动平衡。可惜这块的技术恐怕他是一窍不通。

接下来，他又拿着basic的代码和C，汇编相比较，说basic的代码简洁而C繁琐，汇编就更不用说。

真是太不巧了，本人学电脑就是从basic上手，后来转而学习C/C++和汇编的，语言之间的差异也算知道一些，basic虽然简洁但是操作能力实在的有限的很，而且其语法和设备的操作模式也大相径庭。对于简单的应用和常用的功能，用basic确实可以极大提高开发速度（以牺牲少量运行速度为代价），这也是VB相当长时间火热的原因之一。但是对于正在迅速发展，而业界又比较缺乏统一标准的单板机环境来说，basic的跟进速度恐怕就太慢了，而且不同的厂商一般都提供汇编和C的资料，basic的例程和工具也非常少，而市面上basic的开发工具也是少的可怜，如果应用在产品开发，还不知道要面临什么样的困境。

而C有个很大的好处是，不同种类的单板机，一些例程都是统一的，用C开发的产品可以较低的代价从一种芯片移植到另一种芯片，这一点是汇编和basic都难以达到的（目标芯片有可能根本就没有basic开发环境）

而语言之间的优劣从来都是个没有结果的争论，而对于特定的场合，性价比最高的那种语言的实现才会成为首选。

就单板机环境来说，个人认为C的地位被动摇的日子还远的很。

后来他还说了制作线路板等等这些细节如何繁琐，新手如何难以应付。

这点我倒是很赞同，对于缺乏电路知识的人来说，自己焊接线路板的确是很痛苦的事情，但是由于单板机特殊的环境，电路知识的欠缺最终将导致开发者在技能提升上面临困境。

从长远角度来说，电路知识是个必要的技能，我个人更建议在进入单板机世界之前，先对模拟电路，晶体管电路以及数字电路的基础知识做一定的了解，对于今后的学习和实践是大有裨益的。

不过DSP,ARM体系，似乎对电路方面的要求会低一些，这些单板机的开发环境也许更接近于PC（相对8位RISC芯片来说）。

最后，别人还希望我对他的产品做一个评价，但是我总觉得当面泼凉水不太好，我跟他又不熟，所以只能说，我不是从事这方面开发的，对于这个东西难有恰当的评价。

以我现在的观点，未来的单板机环境，basic和其他语言也会有一席之地，随着硬件水平的提高，甚至解释型的语言也会占据一些份额，但是这个时间不会很快来临。

而且，在PC平台上，VB有M$作为后盾才有所发展，单板机的世界似乎缺乏一个推动basic发展的强大势力，虽然已经有人在basic应用于单板机方面做了相当的努力，但是成效似乎并不是很显著。

和basic相关的单板机开发请参考 www.mcselec.com

《漂洋过海来看你》

Panic — Wed, 26 Apr 2006 14:20:00 GMT

《漂洋过海来看你》
词曲：李宗盛
演唱：娃娃

为你我用了半年的积蓄漂洋过海的来看你
为了这次相聚
我连见面时的呼吸都曾反复练习
言语从来没能将我的情意表达千万分之一
为了这个遗憾
我在夜里想了又想不肯睡去
记忆它总是慢慢的累积
在我心中无法抹去
为了你的承诺
我在最绝望的时候都忍着不哭泣
陌生的城市啊
熟悉的角落里
也曾彼此安慰
也曾相拥叹息
不管将要面对什么样的结局
在漫天风沙里
望着你远去
我竟悲伤得不能自己
多盼能送君千里直到山穷水尽
一生和你相依

单板机开发手记

Panic — Wed, 26 Apr 2006 14:09:00 GMT

单板机开发手记

作者： Panic 2006年4月26日

前一段时间想要DIY个自行车灯，寻找合适的集成电路，发现只有美信(MAXIM)有合适的产品，但是价格太贵了($1.6左右)，而且罕见零售。

最后在肉丝的推荐下，使用8位单板机模拟集成电路的功能。

考虑到需要结构简单价格便宜，选用了ATMEL的ATtiny13。

由于对单板机完全没有概念，所以一上手就没有什么进展，连单板机的频率一类的都搞不清楚。

注册了几个单板机论坛，提了些问题，回复甚少，而且也罕见有实质意义的答案。

最后没办法，只好苦啃datasheet，然后根据提供的例程和开发工具自带的例子，开始了艰难的单板机之旅。

单板机和PC相比，有如下特点：

一，对外部设备依赖性极强。

单板机的外部设备，根据应用千差万别，没有什么通用的环境，换一个应用就换一个环境，而不同应用的例子代码几乎没法参考，最有价值的参考代码还是库函数和datasheet的例子。

二，低端单板机，资源极端匮乏。

我选用的ATtiny13，只有1k flash，32个8位寄存器，64字节SRAM(内存)，64字节EEPROM。而在极限状态，主频只有20M，我实际使用的是9.6M主频。

在这种空间内写程序真的是一种考验。

三，难以调试。

多数时候，程序都是在模拟器上面跑。烧录到芯片后，实际工作状态还受外围电路的影响，任何环节出错都会导致错误的结果，而最郁闷的是在芯片上面跑的程序出错，还没法得到错误状态。

四，对开发者的电路知识要求高。

写PC软件几乎不需要什么电路知识，但是单板机不同，虽然有很多现成的试验板，但是这些试验板根本没法针对特定的应用做开发，充其量只能算例子。

自己需要的电路只能自己设计（当然，如果你要做一件已经有成熟电路的产品，就无所谓了），自己购买元件，自己焊接。最后还要自己检查和验证电路的正确性。

经过努力，我的电路终于可以工作，而且程序也即将完工了，只是现在还有部分元器件没有买到。

这个过程中，没有很系统的经验，只有一些教训和细节和大家分享。

1，首次烧写程序的时候，芯片没有加电，烧写没有成功--b。

2，编译器没有开启优化，导致少量功能就占据了巨大的空间(1.67k)，我添加新函数的时候，居然提示我已经超出器件的flash容量。

后来开启了优化选项，算是解决了这个问题。hex文件的体积从1.67k 降低到了814字节。（hex文件的体积大概相当于实际flash占用的2倍）

3，进一步的优化。

我对存在的代码又做了一次优化，把多数函数调用都改成了宏。

因为函数调用是开销很大的行为，当函数内容比较短小的时候，调用本身的体积和速度开销远远超过了函数执行体，这时候用宏替代函数就是最直接的优化方法。

只有当函数体很长，并且调用比较多的时候，用函数形式才比较有价值。

基本的原则是：只在一个地方调用的函数，全部改成宏；调用开销大于函数体开销的函数，全部改成宏。调用开销小于函数体开销，但是希望执行速度快的函数，可以考虑改成宏。

函数改写为宏，用如下手法：

/*函数形式*/
void f(char a)
{
/*函数体*/
}

/*宏形式*/
#define f(a)\
do{\
/*函数体*/\
}while(0)

对于void类型返回值的函数，这样做就足够了，调用的地方完全不需要修改。如果需要处理返回值，可以使用其他形式，不过个人更习惯用一个全局变量接受返回值。

4，尽量避免使用多字节的数据类型。

借助库函数，8位的单板机可以完整支持short，long甚至float,double一类的多字节类型，但是对这些类型的操作导致代码体积的膨胀是很恐怖的，除非万不得已，否则坚决避免。

5，尽量避免使用芯片不直接支持的操作。

ATtiny13不支持乘法和除法，尽量避免使用需要这类运算的算法和逻辑。原因同4。

6，输出调试信息和中间值。

没有PC开发中那些printf，cout，TRACE，OutputDebugString之类的功能可用，更不能用messagebox报错和中断程序执行。

我迄今为止能想到的保存并提取错误信息的方法就只有使用EEPROM。

利用烧写器可以读取EEPROM的内容，我正在考虑把运行中的数据写入这个空间，然后读取以得到程序的状态和错误信息。

因为程序功能基本实现并且目前还没有什么错误，所以这个功能现在仍在构造中。

7，除了完全依赖中断运行的单板机之外，单板机主要的流程就是一个死循环，我没有看过其他人是怎么处理主流程，以我个人的经验，主流程是一个类似下面的结构：

while(1) /*死循环*/
{
switch(state)
{
    case INIT: /*初始化状态*/
        break;
    case WORK: /*工作状态*/
        break;
    /*其他状态类似处理*/
}
}
依靠切换状态来实现不同功能的切换。这个和windows的消息循环很相似。

8，中断的处理

如果是用C开发，则编译器会自动帮你做现场保护和调用返回的工作（汇编的话，有些东西要自己处理）。中断和主流程之间的数据传递也几乎只能依靠全局变量进行。

9，感觉。

除了对C语言有少许要求之外，单板机开发几乎是完全面向应用的，没有太多现成的东西可用，除了要熟读芯片的datasheet之外，最重要的事情恐怕就是要对周边的电路和设备有比较清晰的认识。

10，一些免费单板机开发软件下载：

双龙的下载器，支持的芯片种类多，运行也很可靠。

小马下载器，老外的产品，国内做了汉化

 ATMEL官方的相关开发工具。

WinAVR，我目前使用的AVR C编译器，GCC核心。

我的程序最近就可以搞定了，只是需要的配件不知道什么时候才能买到，我现在需要的配件清单如下：

1，贴片功率电感，最大电流1A，直流电阻尽量小。电感值
33uH
100uH
330uH
接近即可，不需要完全相同。

2，贴片场效应管，型号有下面的任何一种都可以。
IRF7210
IRF7220
IRF7233
IRF7410
IRF7420
IRF7433
IRF7702
IRF7425
IRF7707

3，贴片肖特基二极管，最大电流1A

4，贴片电阻，1/8～1/16W，阻值
10k
60k

5，贴片电容，耐压16V即可，容量
1uF
10uF

6，贴片稳压管，15～20V

如果有人有这方面的网上零售或者邮购渠道，请在本博客留言。谢谢。

看了这个图，就会明白沙尘暴是多么正常的一种现象～

Panic — Wed, 19 Apr 2006 09:34:00 GMT

《消费者权益保护法》扫盲，并相关知识解说

Panic — Sat, 15 Apr 2006 12:59:00 GMT

《消费者权益保护法》扫盲，并相关知识解说

作者： Panic 2006年4月15日

虽然目前国内法制仍不完善，但是对于已经制定并实施了很久的《消费者权益保护法》，无论是消费者还是商家，仍有相当的认识不足。

《中华人民共和国消费者权益保护法》，（以下简称《消法》）从法律角度规定了经营者和消费者在进行商品买卖的过程中所拥有的权利和应该承担的义务。

这些权利和义务是双方平等交易所应该具有的最基本的保障。

法律完整条文请参考

http://www.hd315.gov.cn/gcs/19qu/pinggu/flfg/law_xfzbhf.htm#top

对消费者而言，所拥有的权利有这么几个方面(法律原文以及政府相关部门的规定原文，均以粗体表示)：

第七条消费者在购买、使用商品和接受服务时享有人身、财产安全不受损害的权利。
消费者有权要求经营者提供的商品和服务，符合保障人身、财产安全的要求。

这一条规定的主要是商品和服务本身的安全性，比如手机电池爆炸，就属于使用商品时安全受到损害的情况。

第八条消费者享有知悉其购买、使用的商品或者接受的服务的真实情况的权利。
消费者有权根据商品或者服务的不同情况，要求经营者提供商品的价格、产地、生产者、用途、性能、规格、等级、主要成份、生产日期、有效期限、检验合格证明、使用方法说明书、售后服务，或者服务的内容、规格、费用等有关情况。

这一条规定的是商品和服务本身说明信息，明码标价是这一规定首要的要求。其后规定的包括产地，生产者等信息，有些因为不十分重要而很容易被忽略，例如玻璃杯的生产日期，由于正常的使用中，玻璃自身的寿命几乎是永久的，所以其生产日期和有效期限就不那么重要，即使商家没有标注，也不认为是违法，而其使用方法，因为属于常识，所以一般也不需要标注。但是如果消费者要求商家提供，则商家必须出具相关资料证明。

第九条消费者享有自主选择商品或者服务的权利。
消费者有权自主选择提供商品或者服务的经营者，自主选择商品品种或者服务方式，自主决定购买或者不购买任何一种商品、接受或者不接受任何一项服务。
消费者在自主选择商品或者服务时，有权进行比较、鉴别和挑选。

这一条主要是限制商家的商品捆绑行为。微软就因其操作系统绑定IE遭到起诉，可见这条规定是具有国际意义的。同时这一条也规定了商家不能干涉消费者的选择，所以无论导购人员如何热心，他都不能直接从你的腰包掏钱付帐。

第十条消费者享有公平交易的权利。
消费者在购买商品或者接受服务时，有权获得质量保障、价格合理、计量正确等公平交易条件，有权拒绝经营者的强制交易行为。

这一条规定限制的商家强行销售的行为，也就是所谓的店大欺客。

第十一条消费者因购买、使用商品或者接受服务受到人身、财产损害的，享有依法获得赔偿的权利。

这一条规定了商品或服务在正常使用中，造成消费者损失的，消费者有权获得赔偿。非正常使用则不在此列。

第十二条消费者享有依法成立维护自身合法权益的社会团体的权利。

这一条，不太好说，一般情况下都是找消协，自己成立团体的可行性不是很大。

第十三条消费者享有获得有关消费和消费者权益保护方面的知识的权利。

消费者应当努力掌握所需商品或者服务的知识和使用技能，正确使用商品，提高自我保护意识。

这就是消费者有权了解和学习《消法》相关知识的权利。而这也要求消费者能正确的使用商品和服务，以免因自身原因造成法律无法保护的损失。

第十四条消费者在购买、使用商品和接受服务时，享有其人格尊严、民族风俗习惯得到尊重的权利。

经营者歧视，诋毁消费者，以及消费者民族风俗的行为，违背这一条的规定，应该受到制裁。

第十五条消费者享有对商品和服务以及保护消费者权益工作进行监督的权利。
消费者有权检举、控告侵害消费者权益的行为和国家机关及其工作人员在保护消费者权益工作中的违法失职行为，有权对保护消费者权益工作提出批评、建议。

这条说白了，就是遇到问题，该协商的协商，该投诉的投诉，该控告的控告，该批评建议的，就批评建议。

这些是消费者的权利，那么以上这些问题如果出现了，消费者的解决途径是什么呢？《消法》规定了如下的合法途径：

第六章争议的解决
　　第三十四条消费者和经营者发生消费者权益争议的，可以通过下列途径解决：
　　(一)与经营者协商和解；
　　(二)请求消费者协会调解；
　　(三)向有关行政部门申诉；
　　(四)根据与经营者达成的仲裁协议提请仲裁机构仲裁；
　　(五)向人民法院提起诉讼。

这些途径从头到尾，一条比一条严重。事实上，在个人消费行为中，多数都是由前两种途径解决。而即使是请求提交到相关部门，希望采用后三种手段的，除非双方完全无法调和，即使是法院也会建议庭外调解。

对个人来说，如果消费金额不是很大，损失不是很严重，前两种途径一般都能得到比较满意的结果。

经营者在违背了《消法》的规定的同时，在有些情况下还需要承担民事责任。规定如下：

第七章法律责任
　　第四十条经营者提供商品或者服务有下列情形之一的，除本法另有规定外，应当依照《中华人民共和国产品质量法》和其他有关法律、法规的规定，承担民事责任：
　　(一)商品存在缺陷的；
　　(二)不具备商品应当具备的使用性能而出售时未作说明的；
　　(三)不符合在商品或者其包装上注明采用的商品标准的；
　　(四)不符合商品说明、实物样品等方式表明的质量状况的；
　　(五)生产国家明令淘汰的商品或者销售失效、变质的商品的；
　　(六)销售的商品数量不足的；
　　(七)服务的内容和费用违反约定的；
　　(八)对消费者提出的修理、重作、更换、退货、补足商品数量、退还货款和服务费用或者赔偿损失的要求，故意拖延或者无理拒绝的；
　　(九)法律、法规规定的其他损害消费者权益的情形。

这些情况都是很常见的，并且很多经营者也都没有意识到，这些情况发生的时候，民事责任也就随之产生。

与此同时，为了规范经营者的行为，对一些特定的行为，法律还规定了一系列的制裁手段，这些已经不单单是维护某个消费者的利益，而是一种强制的市场规范行为。

第五十条经营者有下列情形之一，《中华人民共和国产品质量法》和其他有关法律、法规对处罚机关和处罚方式有规定的，依照法律、法规的规定执行；法律、法规未作规定的，由工商行政管理部门责令改正，可以根据情节单处或者并处警告、没收违法所得、处以违法所得一倍以上五倍以下的罚款，没有违法所得的，处以一万元以下的罚款；情节严重的，责令停业整顿、吊销营业执照：
　　(一)生产、销售的商品不符合保障人身、财产安全要求的；
　　(二)在商品中掺杂、掺假，以假充真，以次充好，或者以不合格商品冒充合格商品的;
　　(三)生产国家明令淘汰的商品或者销售失效、变质的商品的；
　　(四)伪造商品的产地，伪造或者冒用他人的厂名、厂址，伪造或者冒用认证标志、名优标志等质量标志的；
　　(五)销售的商品应当检验、检疫而未检验、检疫或者伪造检验、检疫结果的；
　　(六)对商品或者服务作引人误解的虚假宣传的；
　　(七)对消费者提出的修理、重作、更换、退货、补足商品数量、退还贷款和服务费用或者赔偿损失的要求，故意拖延或者无理拒绝的；
　　(八)侵害消费者人格尊严或者侵犯消费者人身自由的;
　　(九)法律、法规规定的对损害消费者权益应当予以处罚的其他情形。

这些情况也非常普遍，疯牛病和禽流感的快速传播，除了病毒自身的因素外，(五)的行为也起了推波助澜的作用。

但是这些情况的存在，也客观说明了《消法》在执行力度上仍然有所欠缺，消费者的权益仍然没有得到良好的保障。

特别的，对于邮购和预付款购物，《消法》有针对性的规定：

第四十六条经营者以邮购方式提供商品的，应当按照约定提供。未按照约定提供的，应当按照消费者的要求履行约定或者退回货款；并应当承担消费者必须支付的合理费用。

第四十七条经营者以预收款方式提供商品或者服务的，应当按照约定提供。未按照约定提供的，应当按照消费者的要求履行约定或者退回预付款；并应当承担预付款的利息、消费者必须支付的合理费用。

这里有个句子似乎有歧义：“应当按照消费者的要求履行约定或者退回预付款”。

到底是应当 “按照消费者的要求履行约定” 或者 “退回预付款”
还是应当按照消费者的要求 “履行约定或者退回预付款”。

如果是前者，则商家只要抛出退款的棋子就万事大吉，如果是后者，消费者仍然拥有索取应得商品的权利，是否接受退款的主动权在消费者手里。

个人对此有疑问，希望知道其具体解释的朋友指教。

《消法》规定了相当多的消费者可以要求“赔偿”的情形，但是却没有对赔偿的数额和范围作出规定，这也是《消法》在实施上面临困难的原因之一，唯一一条规定了赔偿数额的条款是：

第四十九条经营者提供商品或者服务有欺诈行为的，应当按照消费者的要求增加赔偿其受到的损失，增加赔偿的金额为消费者购买商品的价款或者接受服务的费用的一倍。

但是由于对怎样的行为构成“欺诈”，没有具体的规定，所以在实际实施中仍然存在诸多争议，在不同的时间，场合，同样行为导致的司法解释经常是不同的。就最高法院的观点，欺诈的界定取决于行为是否是“故意”的，但是由于“故意”是一个非常主观的行为，难以用具体的事实界定，所以概念上仍旧是不完备的。

广东省工商行政管理局是为数不多的对“欺诈”作出具体解释的政府部门之一，这可能和广东的市场经济繁荣有关，其具体规定见于如下网址：

http://www.gdgs.gov.cn/gswd/htm/jy114.htm

具体内容如下：

经营者在向消费者提供商品中，有下列情形之一的，属于欺诈消费者行为：
（1）销售掺杂、掺假，以假充真，以次充好的商品的；
（2）采取虚假或者其他不正当手段使销售的商品份量不足的；
（3）销售“处理品”、“残次品”、“等外品” 等商品而谎称是正品的；
（4）以虚假的“清仓价”、“甩卖价”、“最低价”、“优惠价”或者其他欺骗性价格表示销售商品的；
（5）以虚假的商品说明、商品标准、实物样品等方式销售商品的；
（6）不以自己的真实名称和标记销售商品的；
（7）采取雇佣他人等方式进行欺骗性的销售诱导的；
（8）作虚假的现场演示和说明的；
（9）利用广播、电视、电影、报刊等大众传播媒介对商品作虚假宣传的；
（10）骗取消费者预付款的；
（11）利用邮购销售骗取价款而不提供或者不按照约定条件提供商品的；
（12）以虚假的“有奖销售”、“还本销售”等方式销售商品的；
（13）以其他虚假或者不正当手段欺诈消费者的行为。

该解释把“清仓价”这类广告用语应用其中，足见其针对性之强。

最后，本文所依据的《消法》是

1993年10月31日第八届全国人民代表大会常务委员会第四次会议通过1993年10月31日中华人民共和国主席令第11号公布

的版本，至于《消法》后来的修订和增删，并没有去一一跟踪。如果有和现行法律相悖的地方，还请批评指正。

由于法律的强制性和特殊性，当一件事情涉及法律的时候，这件事情就变得很麻烦，很累，我写此文的目的除了传播知识之外，更希望违背法律的行为在发生前被制止，而不是发生后制裁。

MFC CString的bug（也许是bug，也许是人家的独特设计）

Panic — Mon, 10 Apr 2006 12:28:00 GMT

MFC CString的bug（也许是bug，也许是人家的独特设计）

作者：Panic 2006年4月10日

有人在我的博客留言中提问：

问题如下，Remove扩展Ascii码时，CString好像有问题：

//Test CString, GetLength()

CString s1,s2;
s1 = "123456789\x88\x88\x88\x88\x88\x88\x88";
s1.Remove('\x88');
s2.Format("%d", s1.GetLength());

AfxMessageBox(s2 + ""非常奇怪的值");

我的回复：

个人认为这是CString的一个bug，在CString的内部实现中，对扩展字符做了特殊处理，导致最终s1的内容和其记录的字符串长度不符。
s1的Remove成功执行并且得到了正确结果，但是s1.GetLength()却得到了错误的值。
我没有想到好的解决方案，比较简洁的做法是使用Replace("\x88","")来代替Remove函数。
代码如下：
CString s1,s2;
s1 = "123456789\x88\x88\x88\x88\x88\x88\x88";
s1.Replace("\x88",""); //用Replace，替换需要删除的字符为空即可。
s2.Format("%d", s1.GetLength());

AfxMessageBox(s2 + "非常奇怪的值");

实际跟踪的过程是：

Remove函数体：

int CString::Remove(TCHAR chRemove)
{
CopyBeforeWrite(); //呵呵，CString是COW实现。

LPTSTR pstrSource = m_pchData;
LPTSTR pstrDest = m_pchData;
LPTSTR pstrEnd = m_pchData + GetData()->nDataLength;

while (pstrSource < pstrEnd)
{
  if (*pstrSource != chRemove)
  {
   *pstrDest = *pstrSource;
   pstrDest = _tcsinc(pstrDest); //这里的调用
  }
  pstrSource = _tcsinc(pstrSource); //还有这里
}
*pstrDest = '\0';
int nCount = pstrSource - pstrDest;
GetData()->nDataLength -= nCount;

return nCount;
}

_tcsinc函数体：
__inline _PC _tcsinc(_CPC _s1) {return (_PC)_mbsinc((_CPUC)_s1);}

_mbsinc函数体：
unsigned char * __cdecl _mbsinc(
    const unsigned char *current
    )
{
    if (_ISLEADBYTE(*(current++))) //从这里可以看出，对于多数扩展字符，current被执行了两次++操作。
        current++;
    return (unsigned char *)current;
}

//这是一个矛盾的调用，
//一方面，CString在没有定义UNICODE等宏的时候，是以单个字节作为计量单位的，
//而其底层调用的这个函数却分别对待ASC码（单字节）和多字节字符。
//这个矛盾的结果就是最终Remove函数计算出错，得出了一个错误的字符串长度数值
//经由这两句代码计算
//int nCount = pstrSource - pstrDest;
// GetData()->nDataLength -= nCount;
//这个最终保存的nDataLength，是CString内部用来计量字符串长度的变量，也就是GetLength()的返回值。
//这个数值的错误就导致了所有和这个相关的计算都错了。

我查阅了CString的相关函数，发现只有Replace可以实现类似的操作，解决这个问题并使得代码修改量最小。
我还查阅了STL的string，没有找到类似Remove的功能。

从概念上讲，这个矛盾来源于不同的模块，其内部的约定假设是不同的，CString假设用户完全以单个字节作为单位，而底层的_mbsinc假设用户的多字节字符应该看作一个独立的字符。

类似的问题在PHP中同样存在，请参阅我的随笔《PHP网站开发介绍及资料分享》中，“3，加密/解密系列函数”的部分。

Hotmail vs Gmail

Panic — Tue, 14 Mar 2006 03:00:00 GMT

第一回合，邮件分类
Hotmail使用文件夹分类邮件而 Gmail使用标签。
邮件只能存放在一个文件夹，但是却可以帖多个标签。
Gmail略胜一筹。

第二回合，邮件提醒。
Hotmail只提醒没有被分类的邮件。导致明明收到邮件但是却没有得到提示。
Gmail提醒除垃圾邮件之外的所有邮件。
Gmail胜出

第三回合，自定义过滤器。
Hotmail过滤器只能用来分类。
Gmail过滤器可以用来分类，转发。
Gmail胜出。

第四回合，容量/附件容量。
Hotmail 250M/10M
Gmail 2.7G/10M
Gmail胜出。