The Ruby Way 之幂集

Hal Fulton 的《Ruby之道》里面有一个输出幂集的程序。

1. class Array
2. 
   
3.   def powerset
4.     num = 2**size
5.     ps = Array.new(num, [])
6.     self.each_index do |i|
7.       #print "i := #{i}/n"
8.       a = 2**i
9.       b = 2**(i+1) - 1
10.       j = 0
11.       while j < num-1
12.       #print "j := #{j}, (#{j+a}..#{j+b})/n"
13.         for j in j+a..j+b
14.           ps[j] += [self[i]]
15.           #print "ps[#{j}] = #{ps[j]}/n"
16.         end
17.         #print "j := #{j}/n"
18.         j += 1
19.       end
20.     end
21.     ps
22.   end
23. 
    
24. end
25. 
    
26. x = [1, 2, 3, 4]
27. y = x.powerset
28. print "{"
29. for i in 0 ... y.size-1
30.   print "{#{y[i].join(", ")}}, "
31. end
32. print "{#{y[-1].join(", ")}}}/n"
33. # y is now:
34. #   [[], [1], [2], [1,2], [3], [1,3], [2,3], [1,2,3]]
35. # print {{}, {1}, {2}, {1, 2}, {3}, {1, 3}, {2, 3}, {1, 2, 3}, {4}, {1, 4}, {2, 4}, {1, 2, 4}, {3, 4}, {1, 3, 4}, {2, 3, 4}, {1, 2, 3, 4}}

看了老半天都没看明白，所以加了几条输出，发现了如下规律：
其实它采用的是递归的思想（只不过把递归展开了而已） ，有一半的集合含有某个元素，另一半不含。

为了验证，写了一个递归版本的程序：

1. class Array
2.   def divide_and_conquer(ps, i, j, level)
3.     print "level #{level}: (#{i}..#{j})/n"
4.     if level == 0
5.       ps[j-1] += [self[0]]
6.     else
7.       half = (j - i)/2
8.       divide_and_conquer(ps, i, i+half, level-1)
9.       divide_and_conquer(ps, i+half, j, level-1)
10.       for i in i+half ... j
11.         ps[i] += [self[level]]
12.       end
13.     end
14.   end
15.   
16.   def powerset
17.     num = 2**size
18.     ps = Array.new(num, [])
19.     self.divide_and_conquer(ps, 0, num, size-1)
20.     ps
21.   end
23. end
25. x = [1, 2, 3, 4]
26. y = x.powerset
27. for i in 0 ... y.size
28.   print "#{y[i]}/n"
29. end
30. print "{"
31. for i in 0 ... y.size-1
32.   print "{#{y[i].join(", ")}}, "
33. end
34. print "{#{y[-1].join(", ")}}}/n"
35. # y is now:
36. #   [[], [1], [2], [1,2], [3], [1,3], [2,3], [1,2,3]]
37. # print {{}, {1}, {2}, {1, 2}, {3}, {1, 3}, {2, 3}, {1, 2, 3}, {4}, {1, 4}, {2, 4}, {1, 2, 4}, {3, 4}, {1, 3, 4}, {2, 3, 4}, {1, 2, 3, 4}}

不由得感叹：大师的算法学得这么好！