2005年7月21日随笔档案 - this.Think();

听linkcd继续胡扯吧, 人->商业人员->IT业职员(软件工程师) , 我们先来看看人.

点我查看全文.

posted @ 2006-11-28 14:51 linkcd 阅读(1743) | 评论 (1) | 编辑

前端时间看到Kaneboy的随笔, 提到灵感之源的事, 实在是让人看了心里不好受. 前端时间又刚好看完<My job went to India>, 也觉得是时候整理一下自己的想法了, 于是大家就听linkcd小小胡扯一下吧

点击我查看全文

posted @ 2006-11-24 17:34 linkcd 阅读(1233) | 评论 (1) | 编辑

如何才能用好Email?

Email的重要性我就懒得废话了, 事实上我们都是靠email过活的, 那么要怎样才能高效的使用它呢?
我先扔几块砖头出来, 大家来补充吧

全文链接

posted @ 2006-09-02 17:13 linkcd 阅读(303) | 评论 (0) | 编辑

让Switch-Case/If-Else-If-Else从你系统中走开

【摘要】：是否厌恶了维护庞大的Switch-Case语句，是否认为可以为这些选择逻辑写出更清晰的代码？
恩，我们至少可以来试试。。。

点这里阅读全文

ps：笔者在手头的项目里，见过存在分支多达128种的Case语句，遍布于超过2万行的单一class文件，对其原作者佩服不已～～ @_@

posted @ 2006-02-21 11:18 linkcd 阅读(3521) | 评论 (13) | 编辑

[翻译]每个作者都应该懂的统计学 Part I

因为在研究Six Sigma，需要用到如标准差这种概率论与数理统计里的概念，但是由于个人经历，没有上过这门课程。

没办法，自己找资料来学吧。

下面的翻译，因为不熟悉专业名词，就保留原文吧。如果有问题请指正，谢谢。
原文链接：
http://www.robertniles.com/stats/

Mean
最常见的统计学工具之一，并且易于计算。全部【相加】，再除以【个数】。举个例子：
比方说你现在要为World Wide Widget公司进行统计。该公司9名职员的薪水如下：

总裁年薪：$100,000
2个经理，每人年薪：$50,000
4个工人年薪：$15,000
2个学徒年薪：$9,000

所以你把所有薪水加起来：$100,000 + $50,000 + $50,000 + $15,000 + $15,000 + $15,000 + $15,000 + $9,000 + $9,000（上面工资表中所有的数值），总和是$278，000。然后再除以9（职员人数）

最后，你得到了Mean：$30,889.

不是个很差的平均年薪，是吧？但是注意：WWW公司全部9名职员中只有3名职员可以挣到这个数字，而其他6个人甚至不能挣到这个平均值的一半。

那么，我们应该用什么样的统计工具来分析WWW公司【普通职员】能挣多少呢？现在让我们来看看Median。

Median
无论何时，如果你发现自己在写如【普通职员】，或是【普通家庭】这类字眼，你不会想去用前面讲到的那种平均值Mean。你需要那种能确实表示大众化情况的统计工具，这就是Median。

同样，这个统计也很好用：正如它字面意思一样，Median就是处在中间的值。只要把你的数值从大到小排列起来，中间的那个值就是你的Median。

就WWW公司的情况来说，让我们来排列一下他们的工资：
For the World Wide Widget Co., here are the worker's salaries:
$100,000
$50,000
$50,000
$15,000
$15,000
$15,000
$15,000
$9,000
$9,000

这里有9个职员，那么正好会有个人处在9个人的中间位置，即第五个值：$15，000。这就是Median。（如果你的数值是偶数，那么去算中间2个值的Mean，即把2个最中间的值加起来除以2）

比较同一集合的mean和median，可以让你知道该集合中数值分部情况。在这个例子里面,WWW公司总裁的薪水和普通员工的薪水水平就差距很大。（当然，在现实世界中，仅仅9个数字远远不够提供什么有价值的信息。但是在这里说明概念就够了）

再来一个例子：10个人在Redmond（译注：微软总部所在地）赶公交车。这10个人年薪的Mean是$50,000，他们年薪的Median恰好也是$50,000。

Joe Blow下了车，Bill Gates上了车。

现在，这些乘客年薪的Median仍然是$50,000，但是Mean却攀升到$50 million这样让译者眼红的数字-_-。有人可以说现在这些乘客的平均年薪是$50 million，但事实上其他9名乘客并没有因为Bill Gates上了车就变成了百万富翁。当我们在讨论这辆车上【普通乘客】的年薪时，仍然应该使用Median值：$50，000，这样才能反应真实的情况。

（统计学有个概念被称为：standard deviation，它会告诉我们在一个集合中各个值的分部密度。）

下一课：Percent Change
Percent Change可以很好的帮助人们理解随时间变化的数值。同样，学习这个不会用到比小学3年级数学更高深的知识。

用新值减去旧值，然后再除以旧值，就得到了你要的Percent Change。

例如，Springfield和Capital City去年都有50个罪犯。看起来2个城市的治安都一样，不是吗？也许是，也许不是。让我们来看看2个城市以前的犯罪记录，这样可以用Percent Change来进行比较。

5年前，Captial CIty有42个罪犯，而Springfield只有29个。

新值减去旧值，再除以旧值。好了，你算出来的吧？在5年时间里，Capital City的罪犯增长了19％，而Springfield增长了72％！

理解？

等等！在你计算Percent Change的时候，还有些东西需要考虑。让我们来看看Per Captia

Per Capita
当你在比较多组数字时，Percent change只能让你了解事实的部分真相。另一个重要的统计学概念是每组数值的Per Capita。这个概念能帮助你在不同大小的组间进行比较。

再让我们来看看Springfield和Captial City。今年有800,000人居住在spingfield，600,000居住在Capital City。但是在5年前，Springfield只有450,000人，而Capital City有550,000居民。

为什么这个很重要呢？因为这事实上说明了在过去5年里，Sprinefield市的扩张速度远远大于Captial City。这就解释为何Sprinefield会有更高的犯罪增长率。毕竟，一个城市拥有更多的人口自然也会出现更多的罪犯。

为了找到究竟哪个城市更危险一些，你需要计算一个per capita的罪犯比例（a per capita murder rate），即多少人中会出一个罪犯。

为了找到这个比例，只需要将罪犯的数量除以该市的人口数量。为了得到比较少的小数点，我们一般会在结果上乘以100,000，即每100,000人中会出现多少罪犯。

拿Sprinefield来说哦，50个罪犯除以800,000人，可以得到大约100,000人中有6.25个罪犯。Capital City则是50除以600,000，得100,000人中有8.33个罪犯。

5年前，Springfield的29个罪犯除以当时的人口450,000，大约是每100,000人中有6.44个罪犯。而Capital City是用42个罪犯除以550,000，得到每100,000人中有7.64个罪犯。

仅仅看Percent的话，我们会认为：在过去5年里，Springfield犯罪率增长了72％，而Capital City只有19％。但现在我们分析Per Capita，可以发现每100,000人中，Springfield的犯罪人数下降了近3％，而Capital City增长了近9％。。。

这才是真实的情况。。。

下一课：Standard Deviation
（未完待续）

posted @ 2005-12-18 22:17 linkcd 阅读(1081) | 评论 (2) | 编辑

Castle.MircoKernel Class Diagram - Part I

One picture is worth a thousand words

The Class Diagram of Castle.MicroKernel.Model

Hope it is helpful to understand the Castle MicroKernel architecture.

posted @ 2005-11-15 16:35 linkcd 阅读(1975) | 评论 (13) | 编辑

一个不错的scheme入门PPT

来自于：
Greg J.Badros
University of Washington
CSE-341

文件在这里

posted @ 2005-11-13 22:19 linkcd 阅读(1049) | 评论 (2) | 编辑

人格类型测试结果

您的人格类型是： INTJ （内向-直觉-情感-知觉）

您的工作中的优势：
　　◆ 能够看到事情的可能发展的情况及其内在的含义
　　◆ 喜欢复杂理论及智力上的挑战
　　◆ 有创造性地解决问题的天资，能客观审查问题
　　◆ 即使在面对阻挠时也能义无反顾地去实现目标
　　◆ 自信，且对自己的设想会义无反顾地采取行动去实行
　　◆ 对于在工作中胜任和胜出有强烈的动机
　　◆ 能很好地适应一个人单独工作，独立、自主
　　◆ 标准高，工作原则性强
　　◆ 能创造方法体系和模式达到目标
　　◆ 擅长从事技术性工作
　　◆ 能逻辑地分析地做出决定
　　◆ 坚决果断，有高度的组织能力

您工作中可能存在的不足：
　　◆ 易于像紧逼自己工作一样去逼着别人工作
　　◆ 对那些反应不如你敏捷的人缺乏耐心
　　◆ 不愿意和那些你认为能力没有你强的人一起工作
　　◆ 唐突、不机智、缺乏交际手段，尤其在你匆忙的时候

posted @ 2005-10-05 14:16 linkcd 阅读(725) | 评论 (4) | 编辑

.Net 2.0 下Data Container性能比较: Binary Serialize Dataset vs Custom Classes

我们已经听过太多应该是用 Dataset还是应该使用自定义Class作为container的争论了.

很多Anti-Dataseter 对于.Net 1.1 下面dataset蹩脚的xml序列化方式很是不屑. 不可否认, xml序列化的确是dataset的一大缺陷. 但是Microsoft已经意识到了这个问题, 在即将推出的.Net 2.0中,他们为dataset提供了真正的binary序列化方式.

那么, 改进后的binary dataset性能到底如何呢? 在2.0时代, 什么样的container才是我们正确的选择呢?

本文通过实际的测试结果告诉您 :)
请点击阅读全文.

posted @ 2005-09-01 21:08 linkcd 阅读(1431) | 评论 (0) | 编辑

智能替换DataTable.Select中会导致错误的单引号

看到§猪阿不猪§提到一个DataTable.Select的注意事项: 注意去掉不正确的单引号.

平时项目中,我们一般是直接在写filter语句时这样写

theName = theName.Replace("'","''");
string filter = string.Format("Name = '{0}'", theName);

不过有时候也比较麻烦, 如果你的filter里面code的值一多,处理起来就比较烦.

针对这个问题,以前写了一个专门的replace函数(vb.net),能够智能替换filter中不正确的单引号,并保留正确的单引号.

比如有语句: filter = "Name = 'theN'ame' AND Code = 'd'd'", 把整个filter经过处理之后,得到"Name = 'theN''ame' AND Code = 'd''d'"

不过这个版本的算法比较粗糙 (特别时在处理Like, IN关键字的时候, 实在是恶心的代码 -_-bb) 不过暂时能应付项目的要求, 当然Unit Test也是必不可少的.

大家可以看看,也欢迎提出更好的算法 :)

源代码和Unit Test 代码在这里.(updated: 2005/9/23: fixed some bugs)

最后废话一句: 用Dataset就是麻烦...

posted @ 2005-08-31 18:11 linkcd 阅读(2163) | 评论 (4) | 编辑

Nullable Type is an immutable type

Consider this following code in C# 2.0

int? i = 1;

i++;

Console.WriteLine(i);

int? j = i;

j = null;

Console.WriteLine(j.HasValue);

in fact it was complied like this:

Nullable<int> nullable1 = new Nullable<int>(1);
2

Nullable<int> nullable3 = nullable1;
3

nullable1 = nullable3.HasValue ? new Nullable<int>(nullable3.GetValueOrDefault() + 1) : new Nullable<int>();
4

Console.WriteLine(nullable1);
5

Nullable<int> nullable2 = nullable1;
6

nullable2 = new Nullable<int>();
7

Console.WriteLine(nullable2.HasValue);

please note line 3, when we increased the nullable i, it actually created a new instance of Nullable<int>
new Nullable<int>(nullable3.GetValueOrDefault() + 1)
and in line 6, when we assign null to a nullable instance, it also created a new instance with null value.
nullable2 = new Nullable<int>();

Once we created an instance of Nullable<T>, we can NOT modify the inner value any more. When we modify these value, we actually create a new instance with the new value. Nullable<T> is an immutable type.

It looks like string, right? (though Nullable<T> is a value type)

posted @ 2005-08-25 22:19 linkcd 阅读(767) | 评论 (0) | 编辑

Why does Dataset NOT serialize its BinaryFormat property? (ADO.net 2.0)

I have tested the dataset new "binary serialize" feature in ADO.Net 2.0. Many articals said if we set the dataset's property "RemotingFormat" as "SerializationFormat.Binary", it can serialize itself in binary format.

OK, this propety works well, the output file is much smaller than xml style.

But i got something strange:
If i first set a dataset "RemotingFormat" as "binary" before serialize it into a file, then Deserialize it to a new dataset , the new dataset's "RemotingFormat" value is missing, it become the default value: "XML"!!!

BinaryFormatter bf = new BinaryFormatter();

FileStream fs = new FileStream(System.AppDomain.CurrentDomain.BaseDirectory.ToString() + "ds.dat", FileMode.OpenOrCreate);

DataSet ds = GiveMeFakeData();

ds.RemotingFormat = SerializationFormat.Binary;

bf.Serialize(fs, ds);

fs.Close();

// Check the deserialization performance.

fs = new FileStream(System.AppDomain.CurrentDomain.BaseDirectory.ToString() + "ds.dat", FileMode.Open);

long nowticks = DateTime.Now.Ticks;

DataSet ds2 = (DataSet)bf.Deserialize(fs);

//note here!

//ds2.RemotingFormat == SerializationFormat.XML!

long tickstotal = DateTime.Now.Ticks - nowticks;

Console.WriteLine("Took me : " + tickstotal);

fs.Close();

Then i dig into the source code, i have found

private void SerializeDataSetProperties(SerializationInfo info, StreamingContext context)

{

info.AddValue("DataSet.DataSetName", this.DataSetName);

info.AddValue("DataSet.Namespace", this.Namespace);

info.AddValue("DataSet.Prefix", this.Prefix);

info.AddValue("DataSet.CaseSensitive", this.CaseSensitive);

info.AddValue("DataSet.LocaleLCID", this.Locale.LCID);

info.AddValue("DataSet.EnforceConstraints", this.EnforceConstraints);

info.AddValue("DataSet.ExtendedProperties", this.ExtendedProperties);

}

It looks like the dataset didn't serialize the RemotingFormat Property.

Anyone knows why it like this? Is it a bug or a design decision?

(have reported this issue to MS)

Updated: 2005/9/26

The ADO.net PM (Kawarjit Bedi) has replied this issue:

=== QUOTE ===

The primary motivation for doing that were:
1. Backward compatibility. If a v2.0 client recives DataSet from v2.0 server using BinaryRemoting (set at server side - the client does not know it) and then sends the same DataSet to v1.x client without resetting the RemotingFormat property to XML, it'd break the v1.x client. With the default behavior, it'd not break this case.
2. The value of RemotingFormat property is a like a parameter being passed to the remoting engine, it's more to do with the remoting operation then the DataSet's state, hence the reluctance to serialize the property.

=== END QUOTE ===

So, this is not a bug but a design decision.

Thanks Kawarjit :)

posted @ 2005-08-25 21:00 linkcd 阅读(1562) | 评论 (1) | 编辑

Undocumented Keywords in C#

研究Int32&的时候，无意中发现C#里面还有4个Undocument Keyword，分别是__makeref， __reftype， __refvalue 以及__arglist。其中前三个keyword可以这样用：

int i = 1;

TypedReference tr = __makeref(i);

Type t = __reftype(tr); //t = System.Int32

int i1 = __refvalue(tr, int); //i1 = 1

int i2 = (int)TypedReference.ToObject(tr); //i2 = 1

i++; //i = 2

int i3 = __refvalue(tr, int); //i3 = 2

（关于TypedReference类型MSDN是这样描述的：Describes objects that contain both a managed pointer to a location and a runtime representation of the type that may be stored at that location. 同时TypedReference有
[CLSCompliant(false)]标记）

于是我们可以用下面这种方法来模拟ByRef的参数

public class MyClass

{

public static void Main()

{

int v = 99;

TypedReference trParameters = __makeref(v);

Foo(trParameters);

Console.WriteLine("v = {0}", v); // v = 100

}

public static void Foo(TypedReference tr)

{

if(__reftype(tr) == typeof(int))

{

__refvalue(tr, int)++;

}

比较不爽的就是我们必须在Foo方法体中判断TypedReference包含的类型。

注意如果把Foo写成public static void Foo(ref TypedReference tr)，编译器会抱怨说：Method or delegate parameter cannot be of type 'ref System.TypedReference'。

至于__arglist则可以模拟params关键字，抄个例子：

public void Function(__arglist)

{

ArgIterator iterator = new ArgIterator(__arglist);

for (int count=iterator.GetRemainingCount(); count>0; count--)

{

TypedReference typedRef = iterator.GetNextArg();

Console.WriteLine(__refvalue(typedRef, int));

}

调用它：Function(__arglist(2,3,4)); 输出2，3，4

后注：这4个keyword毕竟是undocument的，微软也没有提供任何支持，所以不排除以后被delete掉。Mono下面的编译器似乎也不支持，不过我在vs2005 beta里面试验还是有效的。

Updated: Flier Lu在他的blog对__arglist的使用作了更深入的探讨，推荐阅读。：）

posted @ 2005-08-18 18:44 linkcd 阅读(1327) | 评论 (5) | 编辑

System.Int32&是个啥？

话说有一天你要用反射来对Target类进行操作，调用Foo函数。

public class Target

...{

 public void Foo(int x, int y, int z)

 ...{

 }



 public void Foo(int x, ref int y, out int z)

 ...{

 }

}

可以看到Foo有2个重载，唯一的区别在于第二个Foo方法签名中有带ref的参数。

如果你直接写:

Target myTarget = new Target();

Type t = myTarget.GetType();

MethodInfo methodInfoWithRefParamters = t.GetMethod("Foo");

那么会在RunTime扔个Exception说： Ambiguous match found.

要想invoke第二个Foo的话，我们必须这样写：

MethodInfo methodInfoWithRefParamters = t.GetMethod("Foo", new Type[] ...{typeof(int), Type.GetType("System.Int32&"),Type.GetType("System.Int32&") });

好吧，现在运行是正常运行了，可是新的问题又来了：这个System.Int32&是个啥东东呢?

先在MSDN/.Net Reflector找找Int32&，没有。Google和查看微软放出的Framework Source Code，同样无果。

得，现成的资料找不到，那只有让我们自己通过做试验来玩玩了。

1。先试试能不能搞一个Int32&的实例出来：

当然，就不用指望直接能在C#里面new一个Int32&了。（如果是unsafe的话，Int32*到还可以）
来试试亲爱的Activator吧：

Type refInt32Type = Type.GetType("System.Int32&");

object myRefInt = System.Activator.CreateInstance(refInt32Type, true);

哎呀，扔了一个“No parameterless constructor defined for this object.”异常出来。

2。好吧，那让我们来看看Int32&有啥样的constructor：

BindingFlags bf = BindingFlags.Public | BindingFlags.Static | BindingFlags.Instance | BindingFlags.GetField | BindingFlags.GetProperty | BindingFlags.NonPublic ;

Console.WriteLine(refInt32Type.GetConstructors(bf).Length);

结果却返回了0。

狠一点，把全部BindingFlags Enum放到bf上去呢，用GetMembers试试呢?


BindingFlags bf = // all values of BindingFlags

Console.WriteLine("count of member in type Int32&: {0}", Type.GetType("System.Int32&").GetMembers(bf).Length);

oops，输出长度还是0！（这个地方不知道使用BindingFlags的方法对不对，还请大家指正）

3。Ok，Ok，不能创建实例就暂时不管它，那让我们用QuickWatch来看看这个Int32&类型有啥属性：

下面是我把Int32，Int32&, Int32*，外加Boolean&类型做对比的结果。（属性值相同的已经略过）

	Int32	Int32&	Int32*	Boolean&
Attributes	1057033	NotPublic	NotPublic	NotPublic
BaseType	{"System.ValueType"}	《undefined value》	《undefined value》	《undefined value》
FullName	System.Int32	System.Int32&	System.Int32*	System.Boolean&
GUID	a310fadd-7c33-377c-9d6b-599b0317d7f2	全是0	全是0	全是0
HasElementType	false	true	true	true
IsAutoLayout	false	true	true	true
IsByRef	false	true	true	true
IsClass	false	true	true	true
IsLayoutSequential	true	false	false	false
IsNotPublic	false	true	true	true
IsPointer	false	false	true	false
IsPrimitive	true	false	false	false
IsPublic	true	false	false	false
IsSealed	true	false	false	false
IsSerializable	true	false	false	false
IsValueType	true	false	false	false

通过这张表我们可以观察到很有意思的结果：
Int32& 是ByRef的（最明显，呵呵），不是ValueType, 不可以序列化，没有Sealed，GUID都是0，BaseType 显示为《undefined value》

请特别注意的是Int32&, Int32*它们IsClass属性为True，说明是个Class，先记下来，在后面我会给大家看一个更有趣的结果。

既然，Int32&和Int32*都说自己有ElementType，那就来看看是什么Type吧：

Type.GetType("System.Int32&").GetElementType(); // Print “System.Int32”

Type.GetType("System.Int32*").GetElementType(); // Print “System.Int32” too.

4．回过头来看看生成的IL代码呢？

如图，只能看到对于ref/out 的参数，使用的是ldloca.s 指令，还是没看到我们的Int32&类型，

5．最后来看看最有趣的发现：
先试试在你的机器上run这3句代码：

Console.WriteLine(Type.GetType("System.Int32&").IsSubclassOf(typeof(object)));

Console.WriteLine(Type.GetType("System.Int32*").IsSubclassOf(typeof(object)));

Console.WriteLine(Type.GetType("System.Boolean*").IsSubclassOf(typeof(object)));

再看结果，呵呵，吃惊吧。以上3句都是输出False。难道说.Net里存在着不是从Object继承的Type吗？可它的IsClass属性是为True的哦～

会不会Int32&不是属于.Net框架的呢？可看看它的AssemblyQualifiedName是“System.Int32&, mscorlib, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089”，也没看出什么问题啊？（汗）

~~个人初步猜测：~~

Int32&类型并不是一个真实存在的类型（原因是通过Reflector没能发现它的踪影），而是在CLR中动态构造的一个类型。MS使用它来“表示/标志”某个ValueType的地址。

2005/08/16 Update：

思归的帖子，以及Joel Pobar的blog对这个问题作出了比较好的解释，有兴趣的读者可以看原文，偷懒的话就听我说一下吧：

ByRef types 是受控指针，在CLR里面也是真实存在的类型。不过因为只有很少的IL指令能够作用与它，所以我们不能创建它的实例。同时，系统也限制我们只能在parameter的位置使用ByRef的类型。值得注意的是Int32&和Int32之间不存在什么关系哦...

posted @ 2005-08-14 20:44 linkcd 阅读(1862) | 评论 (6) | 编辑

《4个程序员的一天》（续）由idior的问题想到的

在《4个程序员的一天》一文中，idior问道：

不知道类似foo(+,-,+,*,/, a) //a is a array
实现a[0]+a[1]+a[2]*a[3]/a[4]这种功能能实现吗?（用FP）

昨晚去看了看scheme的数据结构操作，得出以下解法：（；号后面是注释）
(define (inner-runner 1st-number operators numbers)
(if (= 0 (length operators))
    1st-number
    (inner-runner ((car operators) 1st-number (car numbers)) ; calculate new 1st-number
                          (cdr operators)                                            ; get new operators list
                          (cdr numbers))))                                          ; get new numbers list

(define (Foo operators numbers)
(inner-runner (car opes) ops (cdr opes)))

然后我们来run run试试：3 * 5 - 2 + 4 = 17
> (Foo (list * - + ) (list 3 5 2 4))
等于17 ，得解；)

好了，现在来说下解题的思路：
Setp1：从Numbers中“POP”出第一个数作为初始化操作数，叫做1st-number，。Numbers现在剩下n个数字，我们称这个新的list为Numbers*.

Setp2：然后递归的分别从Operators和Numbers*里“POP”出运算符和第二个运算数，拿来和前面我们拿到的1st- number做运算，把得到的结果当作新的1st-number，连同新的Operators和新的Numbers*，重复step2，直到 Operators变为空。

这时候再回过头来看上面的scheme代码：

先简单说明下scheme的语法：
(list * - + ) ：构造一个list，包含3个元素：*，-， +
(length operators)：得到operators这个list的长度

(car operators)：得到operators这个list的第一个元素。
例：(car (list 1 2 3)) = 1，注意它返回的是一个元素，不是list

(cdr operators)：得到operators这个list从第二个元素开始的子list
例：(cdr (list 1 2 3)) = (list 2 3)，注意它返回的是个子list而不是元素

来看看inner-runner函数，它完成的是step2的工作：
它先看看operators是否为空，如果为空就直接返回1st- number；如果不是，那么分别取得一个operator和一个number，进行（operator 1st-number number）运算，把得到的结果又当作1st-number，连同剩下的operators和numbers进行下一轮的递归。

至于主函数foo就比较简单了。它接受2个list类型的参数：Operators，包含n个运算符，Numbers，包含n＋1个数字（当然你也可以放多于n＋1的数字，不过多的数不会参与运算），Foo做的工作只是取出最初的1st-number，剩下的就交给inner-runner搞定了。

至于预算步骤，让我们来看看（先减少些运算符以缩小运算过程）：
(Foo (list * - ) (list 3 5 2)) =>

(inner-runner
(car (list 3 5 2))
(list * -)
(cdr (list 3 5 2))) =>

(inner-runner
((car (list * -))
3
(car (list 5 2)))
(cdr (list * -))
(cdr (list 5 2))) =>

(if (=
     0
     (length (list -)))
15
(inner-runner
    ((car (list -))
     15
     (car (list 2)))
    (cdr (list -))
    (cdr (list 2)))) => 等于13

怎么样，明白了吧？事实上，scheme很多运算都是靠这种简单的递归来完成的。

如idior所说，这个问题可以在".net下利用delegate的多播可以方便实现, java利用compostion模式也能完成"。（如果idior你有时间的话，能否说明一下compostion的解法呢？毕竟Design Pattern方面你比较熟，呵呵）

而且就表现方面来说，虽然scheme代码看上去比较少，不过对于大多数programmer来说，代码的可读性也是非常重要的。FP的代码咋看上去，的确很让人头晕...@_@

写到这里，我们的Semon同志过来看了看我这post的草稿，对我上面最后一句话很是不屑，然后提了一个问题：

既然已知3 * 5 - 2 + 4 = 17，那么用scheme这样写：(Foo (list * - + =) (list 3 5 2 4 17))，即在operators最后加入一个=号，在numbers最后加入结果17，该语句返回true。(Foo (list * - + =) (list 3 5 2 4 18)) 返回false。

你能用java或C＃实现这个最后判等的功能么？

哇呀，这可把我难倒了...

各位看官，您有啥好建议么？

posted @ 2005-07-21 19:43 linkcd 阅读(2352) | 评论 (9) | 编辑

2005年7月21日

公告

与我联系

搜索

常用链接

留言簿(3)

我参与的团队

随笔分类(15)

随笔档案(20)

My other Blogs

最新评论

阅读排行榜

评论排行榜

this.Think(); (Define (Learn-SICP (Begin (Read Book) (Write Scheme) (Thinkabout It))))
博客园 \| 首页 \| 发新随笔 \| 发新文章 \| 联系 \| 订阅 \| 管理	随笔：20 文章：3 评论：186 引用：2