博客园_海天小阁

程序员？你是数学家还是物理学家？

2011-06-16T00:46:00Z

早晨突然的一个感觉。

在程序员的世界里，存在着数学家和物理学家。

先看看百度百科的相关解释：

数学：

数学是研究数量、结构、变化以及空间模型等概念的一门学科。透过抽象化和逻辑推理的使用，由计数、计算、量度和对物体形状及运动的观察中产生。数学家们拓展这些概念，为了公式化新的猜想以及从合适选定的公理及定义中建立起严谨推导出的真理。

物理：

在物理学的领域中，研究的是宇宙的基本组成要素：物质、能量、空间、时间及它们的相互作用；借由被分析的基本定律与法则来完整了解这个系统。物理在经典时代是由与它极相像的自然哲学的研究所组成的，直到十九世纪物理才从哲学中分离出来成为一门实证科学。

数学对应于算法。物理对应于面向对象。

算法大师精于从数据里面通过精巧的计算，得到我们所预期的结果。

而OO大师则精于构造一个完美的系统，充斥着类、属性、方法、事件。

数学是人类最古老的一门科学了。物理是后辈。同样，在计算机世界里，算法是从这个世界被创造的那天起就存在并且将永远存在下去的。

离开了数学，物理可能就变成了哲学，甚至不能算上一门科学了。同样，离开了算法，面向对象也会失色很多。

之所以发这个博文，以及早上会出现的这个想法。因为一直以来有一个问题：

算法 + 数据结构 = 程序

这个老套的、经典的，你又无法证明他不对的公式，驱使一代又一代的程序员从学习编程的第一天就去努力学习算法。驱使一代又一代的程序员从一开始就认定一定要学通数据结构。

但是世界早已经改变了。

我们已经有面向对象这个东西了。“物理时代”已经到来了。

很明显，物理学专家的数学能力一定比一般人要强。拥有较强数学能力的物理学家可能会有更大的成就。

但是多数物理学家一定不会是大数学家。毕竟大家术业有专攻的。

同样，一个人同时有较高的算法和OO能力是可能的。但是同时是算法和OO大师是很难的。因为这两者在看待客观世界的时候，眼睛里看到的东西是不同的。

学习编程，不能不学习算法。只是看清楚自己的能力、兴趣和特长。

然后选择自己成为一个数学家，或者物理学家。

最后：一家之言，仅供参考。呵呵。

本文链接

谷歌Chrome OS的五个理由不足以成为Windows杀手

2011-05-17T07:32:00Z

博客园的新闻：谷歌Chrome
OS将成为Windows杀手的五个理由

很多观点不能赞同。

因此写一个短文来揭示一下。

1. 具有吸引力的套餐服务和价格

谷歌Chromebook：用每月28美元租赁费用剑指微软PC电脑升级周期。

天啊，每月28美元！一年就是$336.

假设微软每3年有一次客户端Windows版本升级，则Chrome用户3年累计投入了$1008.

Walmart今天的Windows7价格如下

http://www.walmart.com/search/search-ng.do?search_query=windows+7+&ic=48_0&_refineresult=true&search_constraint=3944&ref=125875+4294296134

Windows 7 Ultimate Full $279

Windows 7 Ultimate Upgrade $179

http://www.walmart.com/ip/Microsoft-Windows-7-Home-Premium-3-Users-Family-Pack-Upgrade/12575354

Windows 7 Home Premium 3 Users Family Pack Upgrade $124.54

所以

1、以平均使用3年计算，Windows价格更低

2、Windows XP 直到今天依然可以使用，因此年均分摊成本Windows更低。

3、Windows用户可以选择不升级

4、Windows的家庭包装更为低价。Chromebook如果装两台是不是要花两倍的价格呢？

Chromebook会在价格上有多大优势自然不用多说了

2. 简便易用

Linux操作系统的名声是非常难用。Linux台式电脑，无论是KDE还是GNOME，都需要你重新学习做事的方法，不管你先前使用的是Windows还是Mac
OS X。即使是最新的易于使用的Ubuntu Unity界面，也与其他台式电脑操作系统有很大的不同。

相对而言，Chrome OS使用起来就简单得多，你只要会用网络浏览器，就会用Chrome
OS。它的界面就是Chrome网络浏览器，你没必要学习任何新的东西。只要你会用电脑，你就会用Chromebook。

好吧，这个的确没法子多说。不过指出几个错误。

1、苹果的操作系统，也是某个inux的定制版本。没看见谁抱怨过苹果的操作系统难用，难道都是受虐狂？

2、拿一个浏览器的操作手册和一个操作系统的操作手册相比，的确前者会薄很多。

3、Chromebook能进行磁盘碎片整理么？能进行系统启动参数调整么？能实现鼠标左右键换位么？能实现硬盘加密么？能实现系统防火墙设置么？

能….?

可能有些能实现，不过等很多东西都实现后，这玩意儿还简便易用么？或者说Chromebook的设计者把系统的很多复杂性彻底和直接用户隔离了？

嗯，这有可能会导致后面第四点的安全问题的，除非设计者能面面俱到。

3. 应用程序丰富

这个很容易理解：

1、凡是能在Windows OS上运行的软件，是否都能迁移到Chromebook？

2、凡是能在ChromeBook上运行的软件，是否都能迁移到Windows OS？

结论就是理论上Windows OS的应用程序更丰富。突然发现原文没有用“更丰富”，而是“丰富”？

当然，实际上还要看有没有人来做这个转换，比如Android和苹果的APP理论上应该都能互相迁移，但是实际上还是有点差异。

4. 安全性更高

之所以Windows受恶意软件攻击频率最高，因为装机量最大，也最有攻击价值。

我昨天自己写的一个OS，24小时内没有受到恶意攻击，这点上已经超过WindowsOS了。

ChromeBook说自己不会被攻击？黑暗世界的魔头笑了。

嗯，不联网就不会被攻击。

5. 谷歌品牌知名度高

哦，这个也的确。

不过另一个事实就是谷歌品牌的美誉度逐年下降。

如今的谷歌已经再也不可能成为曾经那个“不作恶”的谷歌了。

不过貌似文章主题是说谷歌Chrome OS和WindowsOS的比较。所以谷歌OS的品牌知名度还远远不及WindowsOS。

2010年WindowsOS的估值是1100亿美元。

2010年MS - Office的估值是860亿美元。

2010年Google的股票市值大约是2000亿美元.

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

写此文不是为了证明WindowsOS的地位永远不会被推翻。

而是为了说明有些事情不能只用脑子来思考（不要自己臆想）。

谷歌OS，至少在目前，是一个价格比WindowsOS高，暴露给客户的可配置项少（不一定是缺点），应用程序不丰富，安全性未知的操作系统。

谷歌的Android能在移动设备上成功，是因为移动设备不需要太多的应用程序和可配置项。

而且，Android已经在为自己复杂的第三方定制版本造成的APP不兼容开始头痛了。国内的吸流量的恶意软件似乎早就遍地开花了。

Windows和Office，微软的两大基石。

至少目前还是强大的，强大到任何挑战本质上都是徒劳的。

至于未来。

自私的说，希望个人有生之年WindowsOS的市场份额不低于60%。

否则，难不成到老了还要另外学一套系

或者，到时候都是类似Chrome OS那样的。开机就用的系统，类似彩电。

希望Chrome OS能带给大家惊喜。

Windows最大的问题，就是比尔盖茨没有实现他当年发布95和XP时候诺言：让老太太也能用PC。

本文链接

螺旋数组算法[下篇]--努力接近需求的本质

2010-12-27T03:57:00Z

终于搞完了。

不过在周末看到了 flyinghearts 的算法，顿时觉得自己白干了，呵呵。

从他那里发现自己下面的算法分析还有改进的地方。

反正也糗大了，好歹留个纪念，第三篇博文如下。

我的算法有两个，其实是三个版本。

1、根据(x,y)坐标和矩形边长n，直接计算目标值，线性填充数组，非优化代码

2、根据(x,y)坐标和矩形边长n，直接计算目标值，线性填充数组，优化代码

3、将算法分散到两重循环之间，也就是说丧失了直接计算的能力，换取更高的执行速度。

先欣赏一种算法分析

首先我的思路是找到螺旋矩阵的规律，尤其是避免判断特定点在四条边。

结果我发现了一个新的规律(结果也就是死在这个分析上了，离真相就差一点点，结果是个谬误。中心1的位置不稳定，计划改成外旋顺时针再进行分析)

从内部的1开始，我们可以找到边长为2，3，4，5，6的螺旋矩阵

按照n边长，可以确定1的坐标，以1为第一块，(2,3,4)为第二块，以此类推。

我们可以根据(x,y)，和1的坐标，计算出(x,y)再哪块上。

然后进一步根据这些信息计算出该坐标上的数值

实际代码如下：

public void GenerateMatrixWithBeginingInfo(int N, int[,] matrix, int startAngle, bool isClockwish,bool isReverse)

{

if (isReverse == true)

this.reverse = -(N * N+1);

this.isClockwith = isClockwish;

this.angle = startAngle;

GenerateMatrix(N, matrix);

}

public void GenerateMatrixWithEndingInfo(int N, int[,] matrix, int endAngle, bool isClockwish,bool isReverse)

{

if (N % 2 != 1)

endAngle = (endAngle + 180) % 360;

this.GenerateMatrixWithBeginingInfo(N, matrix, endAngle, isClockwish,isReverse);

}

public void GenerateMatrix(int N, int[,] matrix)

{

Point p;

//Get point of origin

originPoint = new Point { X = N / 2, Y = (N - 1) / 2 };

for (int x = 0; x < N; x++)

{

for (int y = 0; y < N; y++)

{

//坐标转换

p = processPoint(N, new Point { X=x,Y=y});

matrix[x, y] = GetMatrixValue(N, p);

}

public int GetMatrixValue(int N, Point p)

{

int blockNumber;

int startNumber;

int odd;

odd = N % 2;

//Get block number

//1. get block number

blockNumber = Math.Max(Math.Abs(p.X - originPoint.X), Math.Abs(p.Y - originPoint.Y)) * 2 + Convert.ToInt32(p.X + odd > p.Y);

//2. get startNumber

startNumber = blockNumber - blockNumber % 2;

startNumber *= startNumber;

//3. return value

return Math.Abs((int)(startNumber + Math.Pow(-1,(blockNumber+1))*(p.X + p.Y-2*((N-blockNumber)/2)))+odd+reverse);

}

private Point processPoint(int N,Point p)

{

int tmp;

if (isClockwith == true)

{

switch (this.angle)

{

case 0:

p.X = N - 1 - p.X;

break;

case 90:

if (p.X + p.Y + 1 != N)

{

tmp = p.X;

p.X = N - 1 - p.Y;

p.Y = N - 1 - tmp;

}

break;

case 180:

p.Y = N - 1 - p.Y;

break;

case 270:

if (p.X != p.Y)

{

tmp = p.X;

p.X = p.Y;

p.Y = tmp;

}

break;

}

else

{

switch(angle)

{

case 0:

break;

case 90:

tmp = p.X;

p.X = p.Y;

p.Y = tmp;

p.Y = N-1 - p.Y;

break;

case 180:

p.Y = N-1 - p.Y;

p.X = N-1 - p.X;

break;

case 270:

tmp = p.X;

p.X = p.Y;

p.Y = tmp;

p.X = N-1 - p.X;

break;

}

return p;

}

之所以要坐标转换，因为我默认是把偶数的块放在右上角，这样一来，奇数和偶数的情况下，最后结束的位置是不同的。

例如36在左上角，而25在右下角。

而一般螺旋矩阵的题目都是要求结束点是固定在一个地方的。

因此，我在实际数值计算之前先进行一次坐标转换。

这里这个坐标转换函数没有优化过，是最丑的一个了。

执行效率太恐怖了

不提了，太慢了

对于边长是1000的数组，我的代码是0.17~0.22秒，对比的一个模拟算法的代码只要0.008~0.009秒.

所以做了点优化（扔掉框架数学方法，采用位运算，减少函数调用...）

把代码的功能限定到只考虑从左上角外圈1开始到里面顺时针绕行。毕竟对比代码也只能干这个。要公平么

速度优化后的代码（不建议平时写这种可读性恐怖的代码，俺是被逼无奈，否则俺的乌龟算法没人要的。）

public void GenerateMatrix(int N, int[,] matrix)

{

int reverse, angle;

reverse = -(N * N + 1);

isClockwith = false;

if (N % 2 == 1)

angle = 180;

else

angle = 0;

int blockNumber; ;

int tmp;

int odd;

int value;

int blockX, blockY;

int x = 0, y = 0;

int n1=N-1;

ox = N / 2;

oy = (N - 1) / 2;

odd = N & 1;

int x1, y1;

for (x1 = 0; x1 < N; x1++)

{

if (angle == 0)

{

x = x1;

}

else

{

x = n1 - x1;

}

blockX = x - ox;

if (x < ox)

blockX = -blockX;

for (y1 = 0; y1 < N; y1++)

{

if (angle == 0)

{

y = y1;

}

else

{

y = n1 - y1;

}

blockY = y - oy;

if (blockY < 0)

blockY = -blockY;

if (blockX > blockY)

blockNumber = blockX<<1;

else

blockNumber = blockY<<1;

if (x > y || odd == 1 && x == y)

blockNumber++;

if (blockNumber != 1)

{

value=(blockNumber & (int.MaxValue - 1)) * (blockNumber & (int.MaxValue - 1));

if ((blockNumber &1) == 1)

{

value += x + y - ((N - blockNumber) & (int.MaxValue - 1));

}

else

{

value -= x + y - ((N - blockNumber) & (int.MaxValue - 1));

}

value += odd;

}

else

value = 1;

if (reverse == 0)

matrix[x1, y1] = value;

else

matrix[x1, y1] = -(value + reverse);

}

再测试结果如下：

能看出一点点端倪，我的代码耗时随数组尺寸变化增长略慢一点

继续增加边长

在边长达到2500以后，我的算法在速度上开始胜出。也就是说，虽然多了很多数学计算和逻辑判断，但是整体的执行速度反而快。

常识告诉我们，执行代码行越多越慢，因此这里比较靠谱的解释就是因为我的算法避免了对目标数组的非线性访问，从而在大数据量的时候开始拥有速度优势。

另外，直接模拟算法在边长3500以后出现了明显的不稳定，尤其是在8000这个位置（测了它好几遍，18720是一个极小值，平均值会更大）。而我的算法依然维持近似线性的增长。

具体原因没有深入调查，我认为是和老赵提到过的CPU缓存命中有关。

还能更快么？

最后，为了只求极限速度，同时也是在优化过程中发现有些计算步骤其实是可以分散到Y循环外部去的。

因此暂时先放弃用坐标和边长直接计算数值，转而写一个能顺序访问数组，且仅支持一个螺旋格式的最快速解。

其实这个算法早写了，世界独创的螺旋数组低于n(o^2)的生成算法 2010年3月14日发布

不过当时没同时发布算法代码

现在来欣赏算法分析

先看图

任何一行，都有3个部分组成

左边橙色的跳增部分，中间的递增递减部分，右边的跳减部分

第一行和最后一行特殊，没有左右部分，奇数边长的中心块归给上半边的递增部分。

每行的处理流程

0、行从0开始循环

1、计算必要参数

2、列从0开始循环

4、当前y坐标是否到达递增块起始位置，如是，转6

5、当前位置值等于本行跳增起始值加跳增增加值，转9

6、当前y坐标是否到达本行跳减起始位置，如是，转8

7、当前位置值等于本行跳增结束值加坐标计算偏移，转9

8、当前位置值等于本行跳减起始值加跳减增加值，转9

9、一行是否结束，是转0，否转2

10、所有结束

public void GenerateMatrix(int n, int[,] Matrix)

{

int odd = n & 1;

int point1, point2; //跳增结束点，递增结束点

int base1 = 0, base2 = 0, base3 = 0;

int magic;

int n4;

n4 = n * 4;

magic = 4 * n - 7;

//中间点x坐标

int halfx = (n + 1) / 2;

//填充

for (int x = 0; x < n;x++)

{

//计算结束点

if (x < halfx)

{

point1 = x; //跳增结束点

point2 = n - x; //跳减开始点

}

else//下半区

{

point1 = n - 1- x;

point2 = x;

}

//跳增基数

if (x == 0)

base1 = 0;

else if (x == n - 1)

{

base2 = 3 * n - 1;

}

else

{

base1 = n4 - 3 - x;

if (x < halfx)

{

base2 = base1 + (n4 - 3 - (point1 << 2)) * (point1 - 1);

}

else

{

base2 = base1 + (n4 - 7 - (point1 << 2)) * point1 + 1;

}

//跳减基数

base3 = n + x;

for (int y = 0; y < n; y++)

{

//跳增段

if (y < point1)

{

//x基础数-x行控制+y基础数+y列控制

Matrix[x, y] = base1+(magic-(y<<2))*y;

}

//递增段

else if (y<point2)

{

if (x < halfx)

Matrix[x, y] = base2+ y-x+1;

else

{

Matrix[x, y] = base2 +point1-y-1;

}

//跳减段

else

{

Matrix[x, y] = base3+ (1+(y<<2)) * (n-1-y);

}

程序还是有细微的地方可以进一步优化速度。

不过目前的性能已经很明显了。

比较效果

呵呵，从边长600开始就超越了

一个关于算法效率的思考

我们一直在学算法复杂度：时间复杂度、空间复杂度。

如果仅从一般的估计而言，上面所有的算法都是O(n^2)的。

当边长增加一倍，算法需要的时间就会增加4倍。

但是很明显这种估计只是针对一个算法自身和自身进行比较，两个算法之间，即使大家都是O(n^2)，但是实际上还是有速度快慢之分的。

如果未来还能在性能上提高10%以上，我会再次发文的

呵呵。

本文链接

螺旋数组算法[中篇]--常规数学分析

2010-12-21T08:20:00Z

从农夫三拳的分析开始

在农夫三拳的博文里，我们可以看见一个神奇的公式

f(n) = 4*n^2 - 2*n + 1

当我们把起点1放到螺旋中心后，从内圈开始作为第一圈，如下图，3，13，31，57… 形成了一个符合上述规律的数列。

有兴趣的园友可以进一步利用相同的联立方程求解更多有趣的公式

例如我们选取1，7，21，43，73，111…

设f(x)=an^2+bn+c

得

a+b+c=1

4a+2b+c=7

9a+3b+c=21

解得a,b,c=4,-2,3

x=4*n^2-2*n+3，经检验，能完美计算这个数列。

资料：常规数列分析

等差数列

1，2，3，4，5，6，....，n，n+1

特点：前后项差值相等，可以简单用循环变量获得。

反向等差数列

n+1,n,n-1,n-2, ..., 6,5,4,3,2,1

如果发现反向等差数列，那么用两个逆向等差数列之和去减其中一个就能得到另一个

例如数列A=1，2，3，4，5，6 数列B=6，5，4，3，2，1

则数列A=7-数列B

具体到我们这个螺旋数组，其实只要用N平方去减获得的值，就能轻松实现起点1在螺旋中心还是外围。也就是说，内旋或外旋算法本质是一样的。

等比数列

1，2，4，8，16....n,2*n,4*n...

特点：前后项比例关系一定

1 2^0

2 2^1

4 2^2

8 2^3

观察2的指数，又变回到等差数列了

另外，简单倍数好处理，有时候需要变通

1，1.5, 2.25, 3.375, 5.0625, 7.59375....

呵呵，前后项是1：1.5

其实就是1*1.5^n n=1,2,3,4,5....

二次数列

农夫三拳就是发现了二次数列的秘密，那么有什么办法能发现某个数列是二次数列呢？我也不是很清楚，不过有一个模糊的感觉

如有数列A，求该数列的前后项差，形成数列B

如果数列B是一个等差数列，则数列A很有可能就是二次数列

例如

1，3，13，31，57，91...

计算前后差，获得数列

2，10，18，26，34...

明显看出该数列是公差为8的等差数列

（希望科班出身的兄弟帮忙推演一下，最好能获得充分的数学论证。鄙人当年高数是勉强过关的，如今心里那个悔啊，呜呜....）

Chinese_xu猜想，自变量在整数范围内，任何二次函数f(x)=ax^2+bx+c 的值形成的数列，计算其前后数据项得到的新数列为等差数列。

如果这个猜想为真，那么农夫三拳就可以不要凭直觉去发现二次函数公式了。大家都能有趁手的分析方法了。

在此先谢过各位。

心得：数学是很重要的

从小到大，到学计算机，老鸟们一直教育新手：数学是很重要的

不过没栽过跟头不过有刻骨的记忆。

没见过实例不会有深刻的印象。

没学过、没学好，不丢脸，看不起数学，丢脸。

虽然通过摸索一样可以独创微积分原理，但是有巨人的肩膀不去靠，实在是浪费。

各位和我一样数学基础不怎么样的同仁请每天少泡半小时视频网站，少半小时魔兽，几年后大学数学还是能补得上来的。

我以前的另一个分析

说老半天人家的东西，终于开始说说我自己的货色。

设计思想

由于直接模拟算法的方式是先有1，2，3，4...的数列，然后根据数值计算出对应的X，Y坐标，进行赋值。这导致了对目标数组的访问是非线性的，在数组尺寸较大时会有性能问题。

再说，我有时候会用极端方式去重构代码，No if，No loop。

不逼自己改变，人都是很懒的。

主体思路和农夫三拳是一样的，用X，Y坐标值，努力确定一个参考点的值，然后根据坐标偏移和螺旋数组规律计算并直接获得对应X，Y坐标处的数据值。

这么一来，我们可以按传统方式遍历目标数组，并逐一赋值。

约定术语：

以边长分别为10和11的螺旋矩阵为例，约定一些基本术语用于后续讨论。

圈数

一个矩阵从外到内可以分成很多圈，约定从1开始，依次从内到外编号。

0起点值

第一圈是从1开始，不过为了讨论方便约定起点之前的一个值为0起点值。例如，边长为10的螺旋矩阵，第一圈的0起点值是96，第二圈的0起点值是84。而边长为11的第一圈的0起点值是120，而第二圈的0起点值是112。

基础算法模块

所谓基础算法模块就是在完成整体任务过程中要用到的一些可以分离的步骤。

按螺旋矩阵边长N，以及X、Y坐标确定圈数

如图，当螺旋矩阵边长N=11的时候。行列的对称坐标位置是（5，5）

X=0，10，是第六圈

X=1，9，可能是第五圈

X=2，8，可能是第四圈

X=3，7，可能是第三圈

X=4，6，可能是第二圈

X=5，可能是第一圈

然后考虑偶数边长情况

X=0，9，都是第五圈

X=1，8，可能是第四圈

X=2，7，可能是第三圈

X=3，6，可能是第二圈

X=4，5，可能是第一圈

由此，综合判断，抽象后得到算法如下

按给定(X,Y)，给定边长记作N

圈数I=ABS((N-1)/2.0-X)+(N%2+1)*0.5

圈数II=ABS((N-1)/2.0-Y)+(N%2+1)*0.5

两个结果中较大的一个是所求圈数

进一步可以得到指定圈数对应的最大和最小坐标值

坐标数小=(N-1)/2.0-圈数+(N%2+1)*0.5)

坐标数大=(N-1)/2.0+圈数-(N%2+1)*0.5)

上面这些公式都是奇数和偶数数组通用的，里面使用了模运算以达到这个效果。

已知边长，求指定圈数的0起点值

这个很好解释，其实就是减掉中间的一个平方数就可以了。

已知边长N，求指定圈数R的0起点值

0起点值=N*N-(2R-N%2)*(2R-N%2)

最后整合

已知边长、圈数和坐标，求实际数值

1。按坐标秋圈数

2。计算起点值

3。计算本圈的最大最小坐标

4。根据给定坐标值和最大最小坐标，判断在哪个边上

5。计算最终值

实际代码

public int GetMatrixValue(int N, Point p)

{

int value=0;

int circleNumber,circleNumberX,circleNumberY;

int zeroStart;

int min, max;

//Get circle number

circleNumberX =(int) (Math.Abs((N - 1) / 2.0 - p.X) + (N % 2 + 1) * 0.5);

circleNumberY = (int)(Math.Abs((N - 1) / 2.0 - p.Y) + (N % 2 + 1) * 0.5);

circleNumber = Math.Max(circleNumberX, circleNumberY);

//Get zero start number

zeroStart = N * N - (2 * circleNumber - N % 2) * (2 * circleNumber - N % 2);

//Get min X and min Y

min = (N - 1) / 2 - circleNumber + 1;

max = min + circleNumber * 2 - N % 2-1;

//Get line number

if (p.X < max && p.Y == min) { value = zeroStart + p.X - min+1; }

if (p.X == max && p.Y < max) { value = zeroStart + circleNumber * 2 - N % 2 + p.Y - min; }

if (p.X <= max && p.Y == max) { value = zeroStart + 2 * (circleNumber * 2 - N % 2) - 1 + max - p.X; }

if (p.X == min && p.Y > min) { value = zeroStart + 3 * (circleNumber * 2 - N % 2) - 2 + max - p.Y; }

return value;

}

点评

优点

实现了按输入的X，Y坐标计算得到对应值，对目标数组可以进行简单的循环即可。

缺点

说实话，看着最后那4个IF我还是不爽。极限追求，No IF，No Loop。

感悟，以及对面试官的肺腑之言

什么是算法？排序？查找？树遍历？图路径搜索？

什么是设计模式？世界上只有23种设计模式？

我们都学过不少东西，学校考试的时候，必须按照标准答案往空格上填，往答题卡上描！

可是，世界上有更多东西是没有标准答案的。99.99%的程序设计题，都可以有多种答案，哪怕这个题有多简单。

不同的解决方案，对应不同的思路，不同的思考侧重点。

如果只是招一个码工，那么我多言了。

想招一个程序员，让他做笔试题也是可以的，也是应该的。

不过，评价标准不应该是他写出来的是不是和面试官自己写的(甚至是抄的)答案一致。而是面对问题的解决思路、应变、细节，乃至对自己代码的阐述。

为什么很多HR说难招人？

我感觉可能是很多HR认为“常识”的试题，却是多数埋头工作的人不一定能立刻完美回答得上来。尤其是编程笔试题。

螺旋数组终极算法

好了，马上就要公布我的终极算法了，其实核心已经写好了，计划明天将矩阵转换的部分都搞定后再发，估计在12/23。

No If，No Loop

据路边社消息：完成如上的GetMatrixValue，函数内可执行代码只有5行，当然，硬要嵌成一行也是可以的，而上面的函数，里面的可执行代码要嵌成一行就太勉强了。

导读：

螺旋数组算法[上篇]--直接模拟算法

螺旋数组算法[中篇]--常规数学分析

螺旋数组算法[下篇]--努力接近需求的本质预计12/23日发布

本文链接

螺旋数组算法[上篇]--直接模拟算法

2010-12-21T04:57:00Z

引子：

螺旋矩阵是一个比较经典的算法练习题。多数场景下要求练习者编写程序按螺旋方式填充一个边长为N (N>0) 的二维整形数组。如图

另外，还有的是将1至于螺旋中心，或者逆时针方向演进的。之所以今天发文讨论这个螺旋数组，主要有以下几点：

1、螺旋数组是一个经典习题

2、很多初级程序员至今没有找到理想的解。

由于缺乏正确的程序设计“世界观”，很多初级程序员无法独立探寻比单纯模拟更为巧妙地解，本系列也是为了总结一些常规的分析方法。

3、履行对园友的承诺

本人之前曾在园子里承诺过要发布一个能直接按坐标计算对应值的螺旋矩阵算法，结果迟迟没有成文。并且本人有一个解法至今在网上没有看见有相同或类似的解。因此发布一下，为广大算法爱好者做贡献。

4、为广大被面试的同学出口恶气

用螺旋数组做面试题，我听说过很多次。是不是在1小时内写不出来就是水平差呢？我感觉未必，我会用努力证明所有现有的算法都是有问题的，不优雅的。当你手握“标准”答案的时候，批评对方能力不足是太轻松的事情了。

场景简介

大多数的题目是这样的

常规思路

是人都知道这个螺旋矩阵里面是有规律的，但是这规律却也不是像打印星号直角三角形那么容易发现。

因此多数程序员都是采用“直接模拟算法”。

所谓直接模拟算法，就是很直白得把问题中提出的需求直接用代码方式模拟完成。

其实在多如牛毛的中小型项目中，用这种思路去实现客户需求的做法不说100%吧，95%是一定的。这是一个问题。

回到我们的这个需求，自然就是用一个大循环产生1到N平方的所有整数，然后在循环体内精确地判断矩形的四个边界，并调整实际的X，Y坐标，然后对目标数组的对应位置进行赋值

参考代码

以下代码收集自网络, 没有验证过

http://www.cppblog.com/issayandfaye/archive/2009/11/15/100976.html

http://www.cnblogs.com/drizzlecrj/archive/2007/04/10/706784.html

void Simulate(int n)
{
    int x, y;
    x = y = (n - 1) / 2; //1的位置
    data[x][y] = 1;
    int len = 1;
    int count = 0;
    int num = 2;
    DIRECTION dir = RIGHT;
    while(num  <= n * n)
    {
        for(int i = 0; i < len; i++)
        {
            switch(dir)
            {
            case LEFT:
                --y;    break;
            case RIGHT:
                ++y;     break;
            case UP:
                --x;    break;
            case DOWN:
                ++x;    break;
            default:    break;
            }
            data[x][y] = num++;
        }
        count++;
        if(count == 2)
        {
            count = 0;
            len++;    
        }
        dir = (DIRECTION)((dir + 1) % 4);
    }
}

算法点评

直接模拟算法能解决很多问题,写起来还特别快速.

优点

算法思想直观, 实现简单, 在成功精确控制边界变量时很有成就感。

缺点

由于对目标数组的访问不是线性的, 在50%的情况下是跨行访问, 在数组尺寸较大时会出现细微性能问题。这个可以参考老赵的文章

计算机体系结构与程序性能。我就是从那里学来的。

但是

从园友　农夫三拳 2007年的文章面试题-螺旋矩阵(模拟) 中我们就已经可以发现其实可以找到一定的数学规律，因此下一篇我们开始讨论究竟有多少隐藏的意义在这个螺旋数组当中。

本篇总结

以下是个人牢骚，时间宝贵或不愿意听牢骚的情直接无视。

直接模拟算法，是我们广大程序员最熟悉的码代码的模式。而且它的确能胜任很多工作场合。错不在这个模式，在于我们的思维模式。

当思维模式成为思维定式，框死了我们的思想，从而感觉这个世界就是这样的，编码就是如此的，老子已经有5年编码经验了，老鸟了…..

那么，不幸的是，我们已经失去进步的机会了。

有很多事情我们不敢做，要么没时间做，但是如果连想都不敢想，甚至从来没主动尝试去想。

那么，没有自主思想的人，就是机器人，难听点的是僵尸。

导读：

螺旋数组算法[上篇]--直接模拟算法

螺旋数组算法[中篇]--常规数学分析

螺旋数组算法[下篇]--努力接近需求的本质预计12/23日发布

本文链接

标准答案-有多少人能分得清值类型和引用类型?

2010-12-04T13:50:00Z

引子：

TomiWong 园友发了一个帖子有多少人能分得清值类型和引用类型?

问题：“class、object、string、int、bool、byte、interface、delegate、struct、enum，以上这些哪些是值类型，哪些是引用类型？”

回帖无数，但是我发现多数还是不明真相的群众。少数几个其实已经感觉到了真相，但是没有表达清楚。因此特此撰文，以正视听。

貌似正确的答案

如果要快速给一个一般性而言正确的答案，那么应该如下：

值类型： int, bool, byte, struct, enum

引用类型： class, object, string, interface, delegate

可是问题真那么简单么？难道很多回帖的兄弟都是胡闹？

核心问题

对问题里面的英文理解有歧义

题目应该试图问的，是用这些关键字定义并声明出来的变量分别是值类型还是引用类型

看看几个有代表性的意见：

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

#4楼2010-12-03 17:14 | xiaotie
interface 和其它的不一样吧

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

#14楼2010-12-03 17:26 | Ivony...
在这些东西里面：
object、string、int、bool、byte
是类型

class、interface、delegate、struct、enum
不是类型

只能说使用这些关键字定义的类型是引用类型还是值类型

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

#18楼2010-12-03 17:30 | LeonSun
我就想问一个问题，class是什么类型？object是什么类型？

本来这个题对名词的定义就是模糊的，恐怕出这个题的人概念也是模糊的

别来误导群众了，真的～～～

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

好了，意见还是不少的。让我们从头开始梳理问题出在哪里？

1、区分int类型和int类型变量

2、定义TomiWong问题中提到的int是指int型变量还是指int关键字？

3、然后我们才可以开始回答问题

我们平时说惯了，说int是值类型。教科书式的回答应该类似是：

int类型的变量是值类型变量

由此，我们推导出一个简化的说法

int类型是值类型

不少同学在interface、class、object几个关键字上一下子转不过弯来。的确，这几个东西平时不考虑的。我们只说对象类型的变量是引用类型变量，因此看到class的时候第一反应就是他不能算是对象，类不是对象这个是天条。呵呵

这里就出现一个双重标准的问题：

把问题中的所有东西看作他对应的变量，还是就是看做这个关键字，或者看做其代表的类型

class的中文翻译是类，请问类是什么类型？应该什么都不是

如果都看作是关键字，则这些东西也都什么类型都不是

只有当我们统一把他们都看作是变量，是用这些关键字定义并声明出来的变量的时候，才能心平气和地去回答问题

标准答案

C# 类型体系包含下列几种类别：

值类型、引用类型、指针类型

值类型的变量存储数据，而引用类型的变量存储对实际数据的引用。引用类型也称为对象。指针类型仅可用于 unsafe 模式(往极端上说，指针也是值类型)。

通过装箱和取消装箱，可以将值类型转换为引用类型，然后再转换回值类型。除了装箱值类型外，无法将引用类型转换为值类型。

值类型也可以为空(可空类型如：int?)，这意味着它们能存储法非值状态。

值类型主要由两类组成：

结构、枚举

结构分为以下几类：

Numeric（数值）类型

整型、浮点型、decimal

整型包括：sbyte, byte, char, short, ushort, int, unit, long, ulong

浮点型包括：float, double

bool

用户定义的结构。

引用类型的变量又称为对象，可存储对实际数据的引用。

class、interface、delegate

内置引用类型：object、string

其实这答案都不是我写的

参考文献

类型(C#) 值类型(C#) 引用类型(C#)

我们都需要抽空看看 C#编程指南

本文链接

360公布权威机构对扣扣保镖的测试报告

2010-11-12T11:31:00Z

原文链接

http://bbs.360.cn/3237987/40119072.html

作为技术人员，我一直认为至少有一个是非曲直是可以非常客观衡量的

那就是软件本身是否有问题

11月12日，我国信息安全领域的权威测试机构——中国信息安全测评中心公布了对360扣扣保镖（版本号v1.0.0.1005）的检测报告。检测结果显示，未发现360扣扣保镖存在明显可被利用的脆弱性，未发现扣扣保镖存在自我复制行为，未发现扣扣保镖有不正常的向服务器发送数据的行为，等等。多位专家认为，检测报告证实了360扣扣保镖不是木马病毒，也不存在所谓“后门”和窃取用户隐私、复制QQ好友信息的行为。

那么现在，那些“可以”查杀扣扣保镖的安全软件情以何堪？

跟着腾讯这个流氓，一起脱掉内裤么？

金山？以后拿什么相信你？虽然以前也不很欣赏你

可牛？以后拿什么相信你？虽然以前根本不认识你

继续观察，那些失去诚信，没有道德准则，只有商业利益的公司，最后能挣到几个商业利益

当然，除非下一集连续剧里面，中国信息安全测评中心成了幕后的大反派

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

上网搜了一下，百度的搜索引擎绝对比不过google的

有图有真相

本文链接

世界网络奇观！QQ论坛被可能都是“枪手”的人疯狂灌水

2010-11-03T13:29:00Z

http://w.bbs.qq.com/b-1001023996/l-1.html

留贴纪念

刚去看的时候只有两页了，除了论坛公告意外只有10个新帖，100%都是攻击腾讯的。

每3描刷新一下

旧帖都被管理员删除，不过新的100%攻击腾讯的帖子又出现了

目前已经扩展到4页，不知道是管理员来不及删，还是360请了更多的枪手

希望腾讯能有效统计攻击者的IP地址，然后再公告中明确警告360不要搞如此无聊的行为！呵呵

据说有图有真相

本文链接

也说狗咬狗的价值，谈360和QQ的纷争

2010-11-02T08:12:00Z

略去过程5000字

目前有一种类型的回帖比较有趣：

两家公司狗咬狗，都不是好人。

这种论调的结果是直接有利于腾讯公司的。虽然透视黑两家公司，表面上看大家都吃亏。但是本质是鼓动广大网民不要参与这种所谓垃圾和垃圾之间的对决。它试图公众关注度努力降低。

我不直接评论这种论调的正确性，即使我上面的分析有错误也不是我的重点

重点是即使真的是狗咬狗也是有价值的。

记得上学时候一直有老师，尤其是历史、政治老师说西方的政客其实别看执政党反对党的，本质都是资本家的傀儡，都是为了一己之私的。

所谓国会、议会，对，也是狗咬狗。

不过有些狗和狗咬完后至少会有点结果出来，至少表面上能让其他的狗以后不要互相就相同的问题继续咬，再次咬

不晓得的这次360和腾讯这两个狗咬完后除了一地狗毛会给江湖留下些什么？

PS:本人支持360

即使360的动机再龌龊，经济利益再隐蔽

用错误的手段为你做对你有益的事在中国是说的过去的

而用正确的手段帮你做对你有损的事，谁受得了？

本文链接

没关系，我会永远给.net加油的

2010-06-28T05:11:00Z

最近园子里很热闹，本来不打算说什么。但是看着很多似是而非的观点横飞，还有很多不明真相的群之被误导，实在是忍无可忍。

世界上没有完美的语言，.net浑身有一堆毛病，但是一个程序员应该懂得扬长避短。

我们探讨一个语言的缺点，不是要因此去枪毙他。一个语言能发展到成熟并为世人使用，一定有他存在的位置和意义。否则Lisp这种东西应该很早就灭亡了吧？用铅笔刀去灭哈迪斯？用倚天剑去砍柴？

本文主要和诺贝尔的文章进行探讨，希望不要让将错误的观点误导初级程序员。

对不起，我也是来给.Net泼冷水的（山寨版）

我对诺贝尔文章中提出的.net的缺点总结如下：

安装.net4.0后还要装3.5甚至1.0/1.1，貌似不是向下兼容。结果一个OS上有多个.net版本并存
传统网络编程.net没优势，不过诺贝尔不确认，因为不搞很久了
Java社区有很多框架，架构，几乎是入门必修，而.net社区则只有.net自身框架

逐条注释给不明真相的群众参考

1、安装.net4.0后还要装3.5甚至1.0/1.1，一个OS上有多个.net版本并存

注意！这个是.net比java好的一个极大的优势

Java的jdk或者jre现在有多大？和jre1.1比大了多少？如果Java能够千秋万载的话，20年后jre会有多大？

Java的部署机制是一次完全部署，当然，我不很清楚是否能把jre分成更小的模块进行部署。就我认识的几个Java“玩家”的抱怨中，他们是很羡慕.net框架的安装方式的。

当你获得了一个基于jdk1.3开发的jar包，你必须在OS中安装1.3兼容的jre，否则很可能只能自己亲自到“彻底开源”的java代码中一行一行以硬编码方式去修改源码。

因为，java根本不是向下兼容的，而是jre兼容。

高版本中的一些方法，在低版本中是没有的，低版本中的方法会在高版本中被移除。

除了在一台服务器上安装多个版本的jre环境，否则上述困境无解

再结合java里面那么多的开源框架，而每个框架都可能是基于不同的jre。也就是说，有时候仅仅为了部署一个应用，就要同时多个jre。

并且，jre的安装我不知道如何进一步分拆。也就是说，可能我主要基于jre1.7跑应用

但是可能我用的spring版本仅支持1.5，因此我要另外装个1.5来跑spring。

此时，1.7和1.5的jre都是完全安装版吧？如果有java高人知道如何仅部分安装jre，请告知我。

反观.net呢？答案自在人心。

.net framework是一个增长框架，一个进化框架。即使在一个OS上从1.1到4.0都装上，也就是仅仅安装了.net 一遍，其中没有多少是重复的安装。

如果你的应用只要用到全部2.0以及部分3.5的功能，那么完全可以裁减一个更小的环境，连GAC都可以进一步简化掉一点不用的部分。

所以，增长式的部署是微软.net 框架比Java更好的一个特征。

而Java现有的历史应用程序，例如Spring、Hibernet等，一旦没有开发团队进行版本更新，则未来一定会出现一个为java应用部署多个jre版本的囧状。当然，java社区不会让这种情况出现的。

2、传统网络编程.net没优势，不过诺贝尔不确认，因为不搞很久了

用铅笔刀去灭哈迪斯？用倚天剑去砍柴？

从诺贝尔的文章中看不出他说的传统网络编程是那个级别的传统。如果是说直接控制Stock，TCP/IP的话，那么写一个用于承受大流量、大并发压力的服务端，用.net类库来搞的确不合适。不过，难道用Java就有优势了？比汇编还牛？

我们可以努力压榨C#和.net的性能，不过不能奢望他能做所有的事，还要能干得世界第一。

3、 Java社区有很多框架，架构，几乎是入门必修，而.net社区则只有.net自身框架

诺贝尔阐述这个观点的文字里面，出现了“java就是给代码民工设计的”这个话

我来解释一下我对这个话的理解：

Java难学，难入门。这个多数人都认同。

原因在于，java世界里面有太多的框架。一个初级程序员如果不会用这些框架，找饭碗都难，看看招聘广告就了解了。

所以，我们可以看到大量这样的Java程序员：

满嘴跑框架，能熟练应用主流框架完成任务。除此以外？没了

他们真的理解这些框架的好处吗？能灵活运用这些框架吗？多数是不会的。

只会按照固定的方式配置服务器和框架

然后按照固定的方式在项目中使用框架

看看工地上的民工吧：

那些造金茂大厦的，造鸟巢的民工

他们会告诉你造房子时候很多专业术语

他们能熟练得按照总设计师和监工的要求完成施工任务

他们只会按固定的方式去使用各种施工设备和施工步骤

他们能理解设计师的设计思想吗？能知道各种施工步骤的深入含义吗？

能合理创造新的设计图纸、施工方法、施工设备吗？

所以，这种Java程序员和民工有多大区别呢？

由于要成为一个合格的Java“民工”必须会使用所谓的框架，因此Java社区那里就从入门开始搞这个。其中多数人永远沦为“民工”，而少数人从这个起点开始，逐渐深入了解，学习，最终成为新一代的设计师。

而.net社区，要成为一个合格的.net“民工”必须要了解.net框架，因此，很正常的这里不会着急学习那么多企业级框架。多数.net“民工”同样永远是民工，同样有少数人会逐渐成长为新一代的设计师。

同时，微软自身的框架也已经足够不小的范围内使用了。

甚至，很多超大型的项目是绝不会轻易使用框架的。比如：用Hibernet去搞淘宝全站？

因此。两个社区的表面区别并不代表本质的不同。如果要谈论企业级框架，.net里面也是层出不穷的，只是，大家的层次不同，讨论的也就不同了。

不多说了

最后的总结也是我的一个比较激进的观点，不希望大家来评论

Java的未来就是成为C++。

不是说他有那么牛，而是，从一个主流语言退缩成固守固定市场的一种语言。

因为java能做的，没有什么是.net不能做的，或者未来不能做的

历史上，没有C以前，很多语言都是百家争鸣的

有了C后，也不是全都死掉，大家都会找到一个合适的角落里颐养天年

没有C++以前，对象语言也是很多的，后来就同样沉寂了。

由于C++的学习曲线可怕，给微软一个机会，VB横空出世，成功在中小规模软件快速开发领域把C++挤走，成为主流语言

Java的爆发，在与网络时代的跨平台需求，大IT商的策略，用一个本质上至今没有解决的彻底跨平台口号，征服和忽悠了全世界。

Java和.net的未来胜负，不取决于现在有多少主流应用是用谁跑的。而是有多少新应用是用谁做的。。

有家世界级银行部分的后台程序至今仍然是用Cobol写的。现在诸多的Java企业级应用会在未来提供市场很多Java程序员岗位。但是就Java的一些缺点来看，他在不向下兼容性上还会进一步加剧。

这是一个双王者的时代，两个主流开发语言并存的时代。10多年前是没有的，希望10多年后也早日结束

考虑到IT领域和全世界对微软的偏见，一个刚刚从2002年正式起步，起步时已经落后对手至少2年推广时间的语言，他目前所获得的成就至少不能用失败两字来总结。

而身为拥有Sun这种技术大牛公司、IBM这种神一样的企业、全世界最广泛的狂热开源社区的智力支持、宗教一般自由精神的标榜仿佛拥有道德至高点般的地位。Java如今的成就也似乎不能用彻底成功来形容。

弯道超车依然进行时……

身为C#er，.NETer，我们不用担心性能和部署的问题，

而是要努力学会如何将现有.net框架发挥到极致，用自身优点去PK人家的缺点，同时懂得如何去弥补缺点。

身为.net的拥护者，我们要做的不是去着急抢什么大单子。

很多政府项目的行为往往不光从技术有利性上去考虑。

而是努力普及.net的知识，努力让中小企业能早日在信息化中受益。

让中小业主能实实在在得体会到信息化的收益。

从源头开始控制IT部署环境

本文链接