博客园_Gigabyte

读书笔记三

2010-05-20T00:29:00Z

《编程珠玑》第三章

问题一：请将一个具有n个元素的一维向量x向左旋转i个位置。
例如，假设n=8，i=3，那么向量abcdefgh旋转之后得到向量defghabc。
简单编码，使用一个具有n个元素的中间向量，分n步即可完成功能。
你可以仅用几十字节的微小内存，花费与n成比例的时间来旋转向量么？

方案一：实现一个函数，用来将向量向左旋转1个位置。循环调用此函数i次即可。

本方案节省空间（只需要一个元素的额外存储），但是浪费了时间（需要做很多次中间操作的搬迁）。

 1 int MAIN(vector x, int i, int n)
 2 {
 3     for (int ei = 0; ei < i; ei ++)
 4         x = leftshift1(x, n);
 5 
 6     return OK;
 7 }
 8 
 9 vector leftshift1 (vector & x, int n)
10 {
11     element first = x[0];
12 
13     for (int ei = 0; ei < n; ei ++)
14         x[ei] = x[ei+1];
15 
16     x[n - 1] = first;
17 
18     return x;
19 }

方案二：将前i个元素复制到额外存储中，将后n-i个元素前移i个元素，再把额外存储中的数据拷贝到向量的最后i个空间里。

本方案使用了i个元素的额外存储，过于浪费空间。

 1 int MAIN (vector x, int i, int n)
 2 {
 3     vector y = /*build vector with n elements*/
 4 
 5     //copy i elements from top x to y
 6      memcpy(y, x, i * sizeof(x[0]));
 7 
 8     //copy n-i elements from end x to y
 9      memmove(x, x + i, (n - i) * sizeof(x[0]));
10 
11     //copy i elements from y to end x
12      memcpy(x + (n - i), y,  i * sizeof(x[0]));
13 
14     return OK;
15 }

方案三：设前i个元素为a，后n-i个元素为b。则向量x可以表示为 ab，转换后的向量可以表示为 ba。
而只需要将a和b分别转置得到 a'b'，再对整个向量进行转置，就可以得到最终的向量 ba。

本方案代码简洁清晰，只是计算量增加了一倍（多做了一次位移）。

 1 int MAIN (vector x, int i, int n)
 2 {
 3     x = reserveVector(x, 0, i-1);
 4     x = reserveVector(x, i, n-1);
 5     x = reserveVector(x, 0, n-1);
 6 
 7     return OK;
 8 }
 9 
10 vector reserveVector(vector & x, int startPos, int endPos)
11 {
12     int s = startPos;
13     int e = endPos;
14 
15     while(s < e)
16     {
17         swap(x[s], x[e]);
18         s ++;
19         e --;
20     }
21 
22     return x;
23 }
24 
25  int swap (element & s, element & e)
26 {
27     element t = s;
28     s = e;
29     e = t;
30     return OK;
31 }

方案四：直接计算各个元素的最终位置。
对于前i个元素，假设初始位置为t(0<=t<i)，则最终位置应该是 (n - i + t)
对于后 n-i 个元素，假设初始位置为t(i<=t<n)，则最终位置相当于前移了i，应该是 (t - i)

本方案的代码并没有前述方案的简洁，但是计算量最少，并且没有冗余的搬移。

 1 int MAIN (vector x, int i, int n)
 2 {
 3     int s = 0;
 4     int c = 0;
 5     element f;
 6 
 7     s = 0;
 8     f = x[s];
 9 
10     while (c < n)
11     {
12         //get final position of current element s
13         int e = GetFinalPosition(s, i, n);
14 
15         //store original value in current position to tmp value
16         element t = x[e];
17 
18         //fill current element s into final position
19         x[e] = f;
20 
21         //increase count
22         c ++;
23 
24         //prepare for next
25         s = e;
26 
27         //store original value from tmp value
28         f = t;
29     }
30 
31     return OK;
32 }
33 
34 int GetFinalPosition(int t, int i, int n)
35 {
36     if (t < i)
37         return (n - i) + t;
38 
39     if ((t >= i) && (t < n))
40         return (t - i);
41 
42     return t;
43 }

本文链接

读书笔记二

2010-04-15T17:48:00Z

《编程珠玑》第二章

问题一：给定一个包含40亿个32位整数的文件，整数排列次序随机。请查找一个此文件中不存在的32位整数。

解答：32位整数共有0xFFFFFFFF个。如果用一个bit标示一个整数，一共需要约537MB内存。如果内存足够，就构建一个这样大的位图，就可以很快找到的不存在的整数了。

问题二：问题一中，如果内存限制为100MB，如何实现？

解答：可以采用之前提过的多通道算法，对文件读取六次，每次只读取 [(0xFFFFFFFF / 6) * (n - 1), (0xFFFFFFFF / 6) * n] 范围内的整数。

问题三：问题一中，如果内存限制为只有数百字节，如何实现？

解答：如果采用前面提到的多通道算法，也可以实现，但是这样会需要划分成数百万个通道，并且对文件进行数百万次遍历，代价过大，得不偿失。

换个思路，我们不去对32位整数的数值范围进行划分，转而针对整数的bit位进行划分。这些整数的bit位只有32个，每个bit的取值只有0和1。

首先读取一遍文件，分别记录下bit 0为0和1的整数个数。选择个数较少的一种。

第二遍读取文件，在前一次选择的整数中，分别记录下bit 1为0和1的整数个数。选择个数较少的一种。

第三遍读取文件，在前一次选择的整数中，分别记录下bit 2为0和1的整数个数。选择个数较少的一种。

……

第三十二遍读取文件，在前一次选择的整数中，分别记录下bit 32为0和1的整数个数。

在上述三十二次连续读取过程中，一定会有遇到某次读取完成后，某bit位的某一类值的个数为0的情况。此时，我们就可以输出遗漏的整数：整数的低bit位，由之前的读取过滤规则决定；整数的高bit位可以随意填写；当前统计的bit位直接填写个数为0的那个类别。这样，最多只需要三十二次遍历文件就可以完成搜寻。这个方法的缺点是，需要多次遍历文件中所有的整数，尽管每次只需要上一次需要关注的整数的1/2。

问题四：问题三中，能否减少整数的读取和判断次数？

解答：将问题三的解答略作修改，给每个整数增加一个前缀。第一次遍历文件的时候，将对应bit位为1的整数加上前缀1写入文件1，将对应bit位为0的整数加上前缀0写入文件2。统计完成，下一次遍历直接选取本次生成的两个文件之一。这样每次遍历的整数数量都不超过上一次遍历的整数个数的一半，可以大大减少整数的读取和判断次数。只是需要借助临时文件。

问题五：给定一个包含43亿个32位整数的文件，整数排列次序随机。请查找一个此文件中至少出现两次的32位整数。

解答：如果采用问题一的方法，在向位图的某个bit写入整数存在标志1的时候，判断该bit位是否已经置1。若是，则该整数重复。

如果采用问题二、问题三、问题四的方法，将“选择个数较少的一种”改为“选择个数较多的一种”，将“查找某一类统计数据为0则退出”改为“最后一次遍历查找某一类统计大于1则返回”即可。

本文链接

读书笔记一

2010-04-13T16:50:00Z

《编程珠玑》第一章

问题一：一个文件包含了10,000,000个记录，每个记录的内容是7位的整数。记录不会重复。需要一个程序来读取文件内容，需要将这些记录排序后输出文件，内存限制1M左右。

解答：由于记录不会重复，因此每个记录用一个bit标示，就可以很简单的完成记录的标记和排序。这样需要大约1.25M的内存，时间和空间都不大。

/* Phase 1: initialize set to empty */
for i = [0, n)
    bit[i] = 0
/* Phase 2: insert present elements into the set */
for each i in the input file
    bit[i] = 1
/* Phase 3: write sorted output */
for i = [0, n)
    if bit[i] = 1
        write i on the output file

问题二：问题一中，如果严格限定不能超过1M的内存呢？

解答：多通道进行，以时间换空间。扫描两遍源文件，第一次只检查0x7FFFFFFF以下的数值，标记并输出；第二次读取源文件，此时只记录和检查0x80000000以上的数值，标记并输出。这样需要大约0.63M的内存。

问题三：问题一中，如果每个整数不是最多出现一次，而是最多出现十次呢？

解答：那就需要通过4个bit来记录每个记录，而不是之前的1个bit。这样，内存占用需要扩大四倍。如果仍然保持不变的内存限制，那就只好继续划分多个通道分别处理了。

问题四：问题一中，如果能减少初始化整段bit数组的时间？

解答：两个方法。

方法一：将bit数组定义为没有手动初始化的全局变量，将其编译到bss段中。这样，程序被栽入内存的时候，操作系统自动会将bss段的内容置0。也就是说，可以将系统运行时占用的时间，提前到系统被加载时。

方法二：（书上的解法）设整段数组的元素个数为n，数组为data。另定义两个包含n个元素的数组from和to，初始化全局变量t=0。

当需要设置data[i]的数值前，执行以下代码:

from[i]  = t;
to[t]    = i;
data[i]  = 0;
t++;

这样可以只设置需要设置的元素项，并通过from、to和全局变量t来共同保证数据可靠性，替代通常的把整段数组memset的做法。

偶对书上提供的方法二有疑问：在i和t可能较大的情况下，from和to数组的元素类型就不得不设置为unsigned long，这样耗用的内存未免过大，相比而言真正需要操作的data数组的每个元素仅占1个bit。这样是不是有点得不偿失？

本文链接

计算机加法

2010-02-15T13:48:00Z

数学中最简单的运算就是加法和减法。然而在计算机中，最简单的运算却是 AND、OR 和 NOT。

一、AND

物理课上，我们都作过串联实验。把两个开关依次起来之后，如果还要点亮灯泡，就必须同时闭合两个开关。

将开关闭合定义为1，开关断开定义为0；将灯泡点亮定义为1，灯泡熄灭定义为0。则串联的两个开关与灯泡的关联规则是：

(0 0) -> 0 
(1 0) -> 0 
(0 1) -> 0 
(1 1) -> 1

这个规则与布尔代数中的 AND 操作规则完全一致。

(0 AND 0) -> 0 
(1 AND 0) -> 0 
(0 AND 1) -> 0 
(1 AND 1) -> 1

于是，将串联的开关作为输入，就灯泡的亮灭作为输出，上面的电路图就构成了计算机中AND操作（与门）的基本结构。当然计算机中的与门没有这么简单，实际上是通过两个继电器（或缓冲器）来实现的，只是基本原理如此。与门的符号如下：

二、OR

提到串联自然会想到并联。把两个开关并联起来，如果还要点亮灯泡，闭合任何一个开关都可以了。

同样的定义，开关断开闭合与灯泡亮灭的规则为：

(0 0) -> 0 
(1 0) -> 1 
(0 1) -> 1 
(1 1) -> 1

这个规则与布尔代数中的 OR 操作规则完全一致。

(0 OR 0) -> 0 
(1 OR 0) -> 1 
(0 OR 1) -> 1 
(1 OR 1) -> 1

于是，并联开关的电路图就构成了计算机中OR操作（或门）的基本结构。当然，计算机中实际上还是通过两个继电器（或缓冲器）来实现的。或门的符号为：

三、NOT

除去串联和并联，还有一种电路连接方式，叫做短路。

上面的连接方式中，当开关断开，灯泡点亮；当开关闭合，灯泡熄灭。其关联规则为

(0) -> 1 
(1) -> 0

这正是NOT运算符的运算规则。与AND、OR都需要两个输入不同，NOT运算符的输入只有一个。

(NOT 0) -> 1 
(NOT 1) -> 0

计算机中实现NOT运算符的电路叫做反转器，也就是将输入的信号取反输出。和与门、或门都需要两个两个继电器操作两个输入不同，反转器的实现只需要一个继电器。反转器的符号为：

四、NAND 和 NOR

前面的AND、OR和NOT三个运算符之间是可以组合的。如果反转器跟在与门的输出之后，就构成了“与非门”，其符号如下，运算规则就是将与门的输出反转。

(0 NAND 0) -> 1 
(1 NAND 0) -> 1 
(0 NAND 1) -> 1 
(1 NAND 1) -> 0

同理，如果反转器跟在或门的输出之后，就构成了“或非门”，其符号如下，运算规则就是将或门的输出反转。

(0 NOR 0) -> 1 
(1 NOR 0) -> 0 
(0 NOR 1) -> 0 
(1 NOR 1) -> 0

“与非门”和“或非门”都是需要两个继电器。

五、半加器

布尔代数中的AND、OR和NOT三个运算符、以及NAND、NOR两个组合运算符，是计算机可以通过继电器的电路连接就直接实现的。那通过这五个基本运算符，可以实现数学中最普通的加法运算么？

首先，看一下加法的运算规则。

(0 + 0) ->  0 
(1 + 0) ->  1 
(0 + 1) ->  1 
(1 + 1) -> 10

我们可以把这个规则划分成两个部分：进位与求和。

进  位           求  和    
(0 0) -> 0    (0 0) -> 0 
(1 0) -> 0    (1 0) -> 1 
(0 1) -> 0    (0 1) -> 1 
(1 1) -> 1    (1 1) -> 0

仔细看一下进位的规则，会发现与AND操作的规则完全一致。因此，通过一个实现AND操作的“与门”，就能实现加法中进位的处理。

进   位            与   门 
(0 0) -> 0    (0 AND 0) -> 0 
(1 0) -> 0    (1 AND 0) -> 0 
(0 1) -> 0    (0 AND 1) -> 0 
(1 1) -> 1    (1 AND 1) -> 1

再来看求和的规则，与前面提到的几个规则都不一致，但我们可以通过前述规则的组合来实现：将一个“与非门”和一个“或门”分别作为“与门”的输入，看看运算结果：

((0 NAND 0) AND (0 OR 0)) -> (1 AND 0) -> 0 
((1 NAND 0) AND (1 OR 0)) -> (1 AND 1) -> 1 
((0 NAND 1) AND (0 OR 1)) -> (1 AND 1) -> 1 
((1 NAND 1) AND (1 OR 1)) -> (0 AND 1) -> 0

这个运算的结果与求和的规则完全一致。因此，我们只需要通过“与非门”、“或门”和“与门”的组合，就可以实现计算机加法中求和的处理，其电路图如下：

对于这样复杂的基本操作，我们给他起了一个简单的名字：异或（XOR）。〔啊哈，好熟悉的名字。这个玄妙奇异的运算符，居然是从加法中诞生的。〕异或的符号如下：

现在我们把进位和求和两部分操作合并起来，就可以得到如下进行加法运算的电路图：

现在的这个电路图被称为“半加器”（Half Adder），因为这里只有两个加数的输入，还没有考虑到更低位进行加法时提供的进位。

六、全加器

OK，再把更低位提供的进位作为第三个输入加入我们的计算器中。根据加法规则，我们将之前计算后的求和部分加上更低位的进位，这同样会产生一个进位和一个求和的结果。

啊哦，现在有两个进位要处理了。如果同时为1，岂不是要继续进位？

来分析一下可能性。先假设两次运算的进位均为1。

既然第二次运算的进位为1，就意味着低位进位和前一次运算结果的求和这两个数值必然都为1。

而根据假设条件，第一次运算结果的进位也为1。

那就是说，第一次运算结果的进位和求和都是1。

这是不符合加法规则的。所以，假设不成立:-)

舒了一口气，好在两个进位不可能同时为1。因此，我们最终计算出来的进位结果，应该是这两次进位的或操作（只要有一个进位为1，进位结果就为1）。再给两个进位进行一次OR操作，加上一个“或门”吧。

现在的这张图被称为全加器（Full Adder），它在计算机中通过硬件实现了数学中最最基本的操作：加法。

OK，总结一下。一个“与门”需要两个继电器，一个“或门”需要两个继电器，一个“反转器”需要一个继电器：一个“与非门”需要两个继电器，一个“异或”需要六个继电器，一个“半加门”需要八个继电器，一个“全加门”需要十八个继电器。如果要计算八位数相加的电路，就一个需要一百四十四个继电器了。

继电器实在是太大了。幸运的是，随着技术进步，继电器早已经不在电脑中使用了。世界上的第一台电脑ENIAC就将继电器抛弃，改为了真空管，可仍然占用了170平方米的空间。现在，我们身边运行的电脑，都是使用晶体管代替了真空管。但计算原理仍然保持一致，计算八位数相加，仍然需要一百四十四个晶体管。

本文链接

简繁体转换

2010-02-07T08:25:00Z

在页面上自动进行简体和繁体转换的代码

所未见的2009

2010-01-24T07:26:00Z

质数筛选器

2009-06-17T16:23:00Z

质数筛选器

让自己闪亮

2009-01-03T14:12:00Z

去医院看病

2008-09-27T16:11:00Z

排队三小时，治病只需要十秒钟。 “什么问题呀？哦，小问题。好吃好睡就行啦，开点药回去吃吃吧。下一个！” 继续排队一小时，交钱领药。回家打开包装，发现几瓶药分别治疗：神经病。老年痴呆。中风。偏瘫。 OK，问题来了。知道这是什么病么？

新手训练课

2008-01-15T18:33:00Z

消息来源：Alfred Thompson: How To Teach Your Child to Program M$的Randy Guthrie发现自己的孩子Seth有兴趣学习编程，便开始亲自辅导，并在BOSS的提醒下将辅导的过程以BLOG记之，挺有趣的。如果你也想将某人推入Programmer或者Coder的幻暝界中，不妨参考一下这位微软校园关系经理的博客MIS Laboratory。 Ran...