An HTML attachment was scrubbed...
URL: http://lists.exoweb.net/pipermail/python-chinese/attachments/20040427/15d43a5f/attachment.htm

----- Original Message ----- 
From: "jackphil" <jackphilcn at yahoo.com.cn>
To: <python-chinese at lists.python.cn>
Sent: Tuesday, April 27, 2004 10:19 AM
Subject: Re: 回复:Re: 回复:Re: 回复:Re: [python-chinese] 趣味问题――号码分
配


> 您好：
> 按您的说法，按球考虑(我最初的说明中是按罐考虑的)也是一样的，处理1号球之
> 后为什么接下去一定要考虑n号球(1号球放在n号罐)？我们总可以选非n号球(除了
> 最后只剩1罐1球的情况)作为下一个要处理的球！试以3球3罐为例说明之：
> 首先1好球有2(3罐-1)中放法，假设1号球放入2号罐，现在我们有2球2罐，我们考
> 察3号球，3号球只有1(2罐-1)种，剩下2号球就只有剩下的罐可放，这个思路还可
> 以放止最后一个球放入相同号码罐的情况，比如1号球后考虑2号球(1号球放在2号
> 罐),如果2号球选择1号罐，择剩下3号球3号罐！这里还要一个判定2号球不能放入1
> 号罐，喔，如果10球10罐的话....
> -----
4个球的情况下，就不是3!=6 而是9种情况
分别是
2143
2341
2413
3142
3412
3421
4123
4312
4321
ps,我第一次提出的那个使用word公式编辑器写出来的东西，觉得是正确的
后来不过是为了找到纯数学上更优雅的答案。。。。或者，更加优雅的推导。。。

您好：
按您的说法，按球考虑(我最初的说明中是按罐考虑的)也是一样的，处理1号球之
后为什么接下去一定要考虑n号球(1号球放在n号罐)？我们总可以选非n号球(除了
最后只剩1罐1球的情况)作为下一个要处理的球！试以3球3罐为例说明之：
首先1好球有2(3罐-1)中放法，假设1号球放入2号罐，现在我们有2球2罐，我们考
察3号球，3号球只有1(2罐-1)种，剩下2号球就只有剩下的罐可放，这个思路还可
以放止最后一个球放入相同号码罐的情况，比如1号球后考虑2号球(1号球放在2号
罐),如果2号球选择1号罐，择剩下3号球3号罐！这里还要一个判定2号球不能放入1
号罐，喔，如果10球10罐的话....
-----
liux at gdcn.com 写道:

> *----- 原邮件 -----* *从*: jackphil <jackphilcn at yahoo.com.cn> *日期*:
> 星期二, 四月 27日, 2004 上午8:16 *主题*: Re: 回复:Re: 回复:Re:
> [python-chinese] 趣味问题――号码分配
>
> > 刘兄，您好：
> > 昨天由于就要下班，不及细述，现补充说明如下：
> > 第1罐9种可能，假设是n号球，则考察除n号罐以外的任意号罐，它的可能性是8
> > 种，依此类推...
> > 还有什么疑问吗？
>
> 当然有疑问：）
>
> 第一罐放了n号球的话，n号罐就空出来了，如果下一个球是1号球，那么有9个罐
> 可用；否则有8个罐可用，这样就出现了一次加法运算，如果依次计算，会出现
> 一个递归，我还没理清:P。
>
> 不妨设球是依序使用的，随机投入罐中。1号球显然有9个罐可选；1号球投入了n
> 号罐，如果n=2，2号球有9个罐可选，否则有8个罐可选……
>
> 另：设球的选取是有状态的，1号球投入n1号罐；现取n1号球，则n1号球有9个罐
> 可选；设n1号球投入n2号罐，则取n2号球……此时又出现了加法：如果n2==1……n3
> 球就有了8种选择，否则它只有7种选择，这个设计是最后的底线了，如果n1号球
> 投放时不考虑n2==1，就破坏了随机原则，这种情况下得不到我们所要的结果。
> 前面有位朋友已经推导过种情况。不好意思，我的信收到了家里的机器上，在这
> 里看不到他的名字，再次对他的数学功底表示敬佩
>

此问题当是9!，一个简单的解法如下：
设为球和罐编上号，从1到10。
首先第一个罐有9种方法（除掉1号球），于是选择i号球放入1号罐（i!=1）。此时余下
9个球，且没有一个编号为i，那么第i号罐有8种放法（不是第2号罐哦！），把j号球放
入i号罐。
此时又重复之前的过程，第j号罐有7种放法，。。。

用上面的思路，可用数学归纳法证明总共有9!种放法。

同理，如果此问题变为n个球和n个罐，则有(n-1)!种解法。

在下愚钝，如有不当之处，还请方家指教，:-)

Hollo Ye:

  其实大家考虑的就两种思路：
1： 排除法：
先生成全部序列，然后排除不合题面儿的-- 算法？没有，思路简单，代码明晰，
虐待CPU；

2： 生成法：
分析正确的序列特性，直接生成，计数--- 算法可以有变化，数理要精确，代码复杂？优待CPU；

不过，看题，并没有要求输出所有正确的序列，只要数目，所以难以验证？
建议加一条！
输出所有序列到文件，并提供系统消耗对比！

在下先进行第一类，列举出所有正确的序列，作为正确答案？
然后，想象第三条路！

嗯嗯，同时建议为了快速进行，先玩6个球的情况吧？

/******** [2004-04-27]09:18:08 ; you wrote:


Ye Tao> ----- Original Message ----- 
Ye Tao> From: "jackphil" <jackphilcn at yahoo.com.cn>
Ye Tao> To: <python-chinese at lists.python.cn>
Ye Tao> Sent: Tuesday, April 27, 2004 10:19 AM
Ye Tao> Subject: Re: 回复:Re: 回复:Re: 回复:Re: [python-chinese] 趣味问题――号码分
Ye Tao> 配


>> 您好：
>> 按您的说法，按球考虑(我最初的说明中是按罐考虑的)也是一样的，处理1号球之
>> 后为什么接下去一定要考虑n号球(1号球放在n号罐)？我们总可以选非n号球(除了
>> 最后只剩1罐1球的情况)作为下一个要处理的球！试以3球3罐为例说明之：
>> 首先1好球有2(3罐-1)中放法，假设1号球放入2号罐，现在我们有2球2罐，我们考
>> 察3号球，3号球只有1(2罐-1)种，剩下2号球就只有剩下的罐可放，这个思路还可
>> 以放止最后一个球放入相同号码罐的情况，比如1号球后考虑2号球(1号球放在2号
>> 罐),如果2号球选择1号罐，择剩下3号球3号罐！这里还要一个判定2号球不能放入1
>> 号罐，喔，如果10球10罐的话....
>> -----
Ye Tao> 4个球的情况下，就不是3!=6 而是9种情况
Ye Tao> 分别是
Ye Tao> 2143
Ye Tao> 2341
Ye Tao> 2413
Ye Tao> 3142
Ye Tao> 3412
Ye Tao> 3421
Ye Tao> 4123
Ye Tao> 4312
Ye Tao> 4321
Ye Tao> ps,我第一次提出的那个使用word公式编辑器写出来的东西，觉得是正确的
Ye Tao> 后来不过是为了找到纯数学上更优雅的答案。。。。或者，更加优雅的推导。。。



Ye Tao> _______________________________________________
Ye Tao> python-chinese list
Ye Tao> python-chinese at lists.python.cn
Ye Tao> http://python.cn/mailman/listinfo/python-chinese


********************************************/

-- 
Free as in Freedom

 Zoom.Quiet                           

#=========================================#
]Time is unimportant, only life important![
#=========================================#

sender is the Bat!2.02 CE

----- Original Message ----- 
From: "Who Bruce" <whoonline at msn.com>
To: <python-chinese at lists.python.cn>
Sent: Tuesday, April 27, 2004 10:22 AM
Subject: [python-chinese] whose解答 : 趣味问题――号码分配


> 此问题当是9!，一个简单的解法如下：
> 设为球和罐编上号，从1到10。
> 首先第一个罐有9种方法（除掉1号球），于是选择i号球放入1号罐（i!=1）。此时余
下
> 9个球，且没有一个编号为i，那么第i号罐有8种放法（不是第2号罐哦！），把j号球
放
> 入i号罐。
> 此时又重复之前的过程，第j号罐有7种放法，。。。
>
> 用上面的思路，可用数学归纳法证明总共有9!种放法。
>
> 同理，如果此问题变为n个球和n个罐，则有(n-1)!种解法。
>
> 在下愚钝，如有不当之处，还请方家指教，:-)
>
这位兄台，你的解法，隐含的，将1号球放入乐最后一个罐
所以，在您的解法中，
21。。。
3x1...
4xx1...
或者
312...
类似这样的排列不会出现的您的解法众，所以。。。

----- Original Message ----- 
From: "Zoom.Quiet" <zoomq at infopro.cn>
To: "Ye Tao" <python-chinese at lists.python.cn>
Sent: Tuesday, April 27, 2004 10:24 AM
Subject: Re[8]: [python-chinese] 趣味问题――号码分配


> Hollo Ye:
>
>   其实大家考虑的就两种思路：
> 1： 排除法：
> 先生成全部序列，然后排除不合题面儿的-- 算法？没有，思路简单，代码明晰，
> 虐待CPU；
>
> 2： 生成法：
> 分析正确的序列特性，直接生成，计数--- 算法可以有变化，数理要精确，代码复杂
？优待CPU；
>
> 不过，看题，并没有要求输出所有正确的序列，只要数目，所以难以验证？
> 建议加一条！
> 输出所有序列到文件，并提供系统消耗对比！
>
> 在下先进行第一类，列举出所有正确的序列，作为正确答案？
> 然后，想象第三条路！
>
> 嗯嗯，同时建议为了快速进行，先玩6个球的情况吧？
>
好的，拜托乐。。。

Hollo Ye:

  最笨的方法进行验证：
全部使用类进行了封装，大家可以方便的引用，进行测试自个儿的方法？
运行 python codeBall.py
实际上分三步进行的::
        #建立序列
        order="123456"
        seq = list(order)
        #生成排列
        p = tryPnC.permute(seq)        
        #玩――过滤出切题的
        CB = playCodeBall()
        result = CB.filter(p,order)
        #输出正确的序列到文件
        exp = outputLog.exporter()
        exp.exportArray(result)
        exp.writeInFile("CodeBall.log")
        print "当罐有 %s 个时,全部 %s 种排列中,合题的为:%s 种!"%(len(order),len(p),len(result))

PnC.py中使用了
http://www.chinesepython.org/cgi_bin/moingb.cgi/_d2_bb_c7_d0_b4_d3_d3_ce_cf_b7_bf_aa_ca_bc#head-5af796a81b5278d80666be6f3df99f64cb9cb8f0
中的两种即有的排列生成方法:
permute(self,seq)
根据图景: 

                      [4321]   
                      [3421] 
             [321]  < [3241]      
      [21] < [231]... [3214] 
             [213]... 
[1] < 
             [321]... 
      [21] < [231]... 
             [213]...       

要产生一个排列其实可以用这样一个方法: "先选一个数 1, 然后第二个数 2 可以放在 1 的前面或是后面. 而每一个放法都会产生一个 2 位数, 对於每一个这样的两位数, 第三个数 3, 都可以放在它的前面, 中间, 或是最后; 如此产生一个 3 位数; 而每一个 3 位数, 第 4 位数都可以插入到这 3 个数的任何一个空位中, 如此类推.

permute_O_n(self,seq, index)
"""....
设想有 n 个数字, 先取第一个数字. 再取第二个数字, 第二个数可以放在第一个数的左或右面, 就是有 0, 1 两个选择. 再取第三个数, 放到前面选好的两个数字中, 可以放在最左, 中间, 最右, 就是有 0, 1, 2 三个选择. 嗯, 很自然吗. 忽然你想到了二进位, 八进位那些数系转换关系. "我可以设计这样一个数, ...xyz, 其中个位数 z 是二进位的, 也就是放第二个数的两个位置; 十位数 y 是三进位的, 化表放第三个数字的三个位子, 然后百位数是四进位, 千位数是五进位的, 依以类推." 没错, 这样设计的话, 如果 0 表示放於最左面的话, 则 "2021" 这个数就代表了排列五个元素 (abcde), 取一个 a, 然后第二个 b 放在 a 的右面成 ab, 取 c 放到最右面成为 abc, 取 d 放到最左面成 dabc; 最后 e 放到中间去成为 daebc. 至於 "2021" 这个特别的设计的数可以用 ..+ x*4 + y*3 + z*2 这样的计算来映对到自然数的数列上去. 

没错了, 如求 4 个数的 4! = 24 个排列, 第 18 个排列可以这样求得, 18 除 2, 余数是 0, 所以第二个数放在第一个数的左面; 然后商 9 再除 3, 余数 0, 所以第三个数於在头两个数的最左; 最后 3 除以 4, 余数是 3, 因此第四个数要放在前三个数的第 4 个空位, 也就是最右面. 利用这个方法, 你就不必先求出整个排列才能开始计算. 尽管这好像牺牲了时间, 但省下了大量的空间. 你完全可以算出 1000 个数的最大排列方法, 纵使那可能要用去几个月的运算. 你更高兴的是用这个方法, 你可以把整个计算拆开成为一个一个的部份: 譬如说求 10! = 3628800 个排列, 你大可以把 1 到 1000000 让一部电脑做, 1000001 到 2000001 让另一部来做 ... 大家的工作并不重覆, 这等於实现并行运算了! 啊哈! 妙极了!
"""
其实还是没有完全理解！


ps.
仅仅得到数目，是没有办法进行详细的检验的，希望在下的愚昧可以作为最切实的最终验证！？

/******** [2004-04-27]12:01:15 ; you wrote:


Ye Tao> ----- Original Message ----- 
Ye Tao> From: "Zoom.Quiet" <zoomq at infopro.cn>
Ye Tao> To: "Ye Tao" <python-chinese at lists.python.cn>
Ye Tao> Sent: Tuesday, April 27, 2004 10:24 AM
Ye Tao> Subject: Re[8]: [python-chinese] 趣味问题――号码分配


>> Hollo Ye:
>>
>>   其实大家考虑的就两种思路：
>> 1： 排除法：
>> 先生成全部序列，然后排除不合题面儿的-- 算法？没有，思路简单，代码明晰，
>> 虐待CPU；
>>
>> 2： 生成法：
>> 分析正确的序列特性，直接生成，计数--- 算法可以有变化，数理要精确，代码复杂
Ye Tao> ？优待CPU；
>>
>> 不过，看题，并没有要求输出所有正确的序列，只要数目，所以难以验证？
>> 建议加一条！
>> 输出所有序列到文件，并提供系统消耗对比！
>>
>> 在下先进行第一类，列举出所有正确的序列，作为正确答案？
>> 然后，想象第三条路！
>>
>> 嗯嗯，同时建议为了快速进行，先玩6个球的情况吧？
>>
Ye Tao> 好的，拜托乐。。。



********************************************/

-- 
Free as in Freedom

 Zoom.Quiet                           

#=========================================#
]Time is unimportant, only life important![
#=========================================#

sender is the Bat!2.02 CE
-------------- next part --------------
# -*- coding: gbk -*-
# file codeBall.py
#/*********************************
# \class codeBall
# \brief 	[python-chinese] 趣味问题――号码分配试解
# \version 1.0  04427	liux at gdcn.com 原始提出，现在以最笨方式解决
# \author Zoom Quiet (zoomq at itcase.com)
# \attention 	Released under GNU Lesser GPL library license
# \par
# \return
# \sa
#*********************************/

import sys, os,string
import outputLog,PnC

class playCodeBall:
    def __init__(self):
        self.log=""
    def __repr__(self):# 类自述定义
        print("Zoom.Quiet 最笨方式进行正确解答输出\n 可以作为其它解的验证")
        return self.log
    def filter(self,seq,order):        
        seqCB = []
        length = len(order)
        tag = 0
        for item in seq:            
            for i in range(length):
                if(i == int(item[i-1])):
                    print "bad CodeBall> %s at [%s] = %s"%(item,i,item[i-1])
                    break
                else:                    
                    if(i+1==length):
                        tag = 1                    
            if(1==tag):
                seqCB.append(item)
                #print item
                tag = 0
        return seqCB

if __name__ == '__main__':      # 自测试
    tryPnC = PnC.permutation()            # imported by other programs as well
    if(tryPnC):
        #建立序列
        order="123456"
        seq = list(order)
        #生成排列
        p = tryPnC.permute(seq)        
        #玩――过滤出切题的
        CB = playCodeBall()
        result = CB.filter(p,order)
        #输出正确的序列到文件
        exp = outputLog.exporter()
        exp.exportArray(result)
        exp.writeInFile("CodeBall.log")
        print "当罐有 %s 个时,全部 %s 种排列中,合题的为:%s 种!"%(len(order),len(p),len(result))
    else:
        print("\"\"")
    
    
-------------- next part --------------
# -*- coding: gbk -*-
# file outputLog.py
#/*********************************
# \class outputLog
# \brief 	结果数据输出支持
# \version 1.0  04427	支持字串，和数组输出！
# \author Zoom Quiet (zoomq at itcase.com)
# \attention 	Released under GNU Lesser GPL library license
# \par
# \return
# \sa
#*********************************/

import sys, os,string

class exporter:
    def __init__(self):
        self.log=""
    def __repr__(self):# 类自述定义
        return self.log
    def writeInFile(self,fname):
        open(fname,"w").write(self.log)
        print("成功输出数据到文件:%s"%fname)
        
    def exportArray(self,seq):
        for i in seq:
            self.log += i+"\n"
        return self.log
    def exportTxt(self,txt):
        self.log += txt
        return self.log

if __name__ == '__main__':      # 自测试
    exp = exporter()            # imported by other programs as well
    if(exp):
        import PnC
        tryPnC = PnC.permutation()
        seq = list("1234")
        p = tryPnC.permute(seq)
        exp.exportArray(p)
        exp.writeInFile("exp.log")
        
        #open("PnC.log","w").write(PnC.export)
    else:
        print("\"\"")
    
    
-------------- next part --------------
# -*- coding: gbk -*-
# file PnC.py
#/*********************************
# \class PnC
# \brief 	permutation and combination 排列组合 输出
# \version 1.0  04427	使用"一切从游戏开始 - ChinesePython Wiki"的技巧
# \author Zoom Quiet (zoomq at itcase.com)
# \attention 	Released under GNU Lesser GPL library license
# \par
# \return
# \sa
#*********************************/

import sys, os,string
import outputLog

class permutation:
    def __init__(self):
        self.log=""
        self.export=""
    def __repr__(self):# 类自述定义
        return self.log
    def permute_O_n(self,seq, index):
        seqc = seq[:]
        seqn = [seqc.pop()]
        divider = 2
        while seqc:
            index, new_index = divmod(index,divider)
            seqn.insert(new_index, seqc.pop())
            divider += 1
        return ''.join(seqn)
    def permute(self,seq):
        seqn = [seq.pop()]
        while seq:
            newseq = []
            new = seq.pop()
            #print "seq:",seq,'seqn', seqn ,'new', new
            for i in range(len(seqn)):
                item = seqn[i]
                for j in range(len(item)+1):
                    newseq.append(''.join([item[:j],new,item[j:]]))
            seqn = newseq
            #print 'newseq',newseq
        return  seqn

if __name__ == '__main__':      # 自测试
    tryPnC = permutation()            # imported by other programs as well
    if(tryPnC):
        seq = list("1234")
        #for i in range(30):
            #print tryPnC.permute_O_n(seq, i)
        p = tryPnC.permute(seq)
        #print len(p)
        #for i in p:
        #    print i
        #open("PnC.log","w").write(PnC.export)
        exp = outputLog.exporter()
        exp.exportArray(p)
        exp.writeInFile("PnC.log")        
    else:
        print("\"\"")
    
    

Hollo Zoom.Quiet:

哇呀呀！真的是虐待CPU!
PII 266 128Mb; RedHat 8.0 
Python 2.3.3 (#1, Feb 12 2004, 22:21:49)
[GCC 3.2 20020903 (Red Hat Linux 8.0 3.2-7)] on linux2
运行 9位的数码球游戏:
  
[Zoomq at redhat8 zCodeBall]$ time python codeBall.py
成功输出数据到文件:CodeBall.log
当罐有 9 个时,全部 362880 种排列中,合题的为:148329 种!

real    24m47.861s
user    11m20.844s
sys     12m49.281s

!CodeBall.log 有1Mb!
足够同志们检验新方法了！

/******** [2004-04-27]15:02:03 ; you wrote:

Zoom.Quiet> Hollo Ye:

Zoom.Quiet>   最笨的方法进行验证：
Zoom.Quiet> 全部使用类进行了封装，大家可以方便的引用，进行测试自个儿的方法？
Zoom.Quiet> 运行 python codeBall.py
Zoom.Quiet> 实际上分三步进行的::
Zoom.Quiet>         #建立序列
Zoom.Quiet>         order="123456"
Zoom.Quiet>         seq = list(order)
Zoom.Quiet>         #生成排列
Zoom.Quiet>         p = tryPnC.permute(seq)        
Zoom.Quiet>         #玩――过滤出切题的
Zoom.Quiet>         CB = playCodeBall()
Zoom.Quiet>         result = CB.filter(p,order)
Zoom.Quiet>         #输出正确的序列到文件
Zoom.Quiet>         exp = outputLog.exporter()
Zoom.Quiet>         exp.exportArray(result)
Zoom.Quiet>         exp.writeInFile("CodeBall.log")
Zoom.Quiet>         print "当罐有 %s 个时,全部 %s
Zoom.Quiet> 种排列中,合题的为:%s 种!"%(len(order),len(p),len(result))

Zoom.Quiet> PnC.py中使用了
Zoom.Quiet> http://www.chinesepython.org/cgi_bin/moingb.cgi/_d2_bb_c7_d0_b4_d3_d3_ce_cf_b7_bf_aa_ca_bc#head-5af796a81b5278d80666be6f3df99f64cb9cb8f0
Zoom.Quiet> 中的两种即有的排列生成方法:
Zoom.Quiet> permute(self,seq)
Zoom.Quiet> 根据图景: 

Zoom.Quiet>                       [4321]   
Zoom.Quiet>                       [3421] 
Zoom.Quiet>              [321]  < [3241]      
Zoom.Quiet>       [21] < [231]... [3214] 
Zoom.Quiet>              [213]... 
Zoom.Quiet> [1] < 
Zoom.Quiet>              [321]... 
Zoom.Quiet>       [21] < [231]... 
Zoom.Quiet>              [213]...       

Zoom.Quiet> 要产生一个排列其实可以用这样一个方法: "先选一个数 1,
Zoom.Quiet> 然后第二个数 2 可以放在 1 的前面或是后面. 而每一个放法都会产生一个
Zoom.Quiet> 2 位数, 对於每一个这样的两位数, 第三个数 3, 都可以放在它的前面,
Zoom.Quiet> 中间, 或是最后; 如此产生一个 3 位数; 而每一个 3 位数, 第 4
Zoom.Quiet> 位数都可以插入到这 3 个数的任何一个空位中, 如此类推.

Zoom.Quiet> permute_O_n(self,seq, index)
Zoom.Quiet> """....
Zoom.Quiet> 设想有 n 个数字, 先取第一个数字. 再取第二个数字,
Zoom.Quiet> 第二个数可以放在第一个数的左或右面, 就是有 0, 1 两个选择.
Zoom.Quiet> 再取第三个数, 放到前面选好的两个数字中, 可以放在最左, 中间, 最右,
Zoom.Quiet> 就是有 0, 1, 2 三个选择. 嗯, 很自然吗. 忽然你想到了二进位,
Zoom.Quiet> 八进位那些数系转换关系. "我可以设计这样一个数, ...xyz, 其中个位数
Zoom.Quiet> z 是二进位的, 也就是放第二个数的两个位置; 十位数 y 是三进位的,
Zoom.Quiet> 化表放第三个数字的三个位子, 然后百位数是四进位, 千位数是五进位的,
Zoom.Quiet> 依以类推." 没错, 这样设计的话, 如果 0 表示放於最左面的话, 则
Zoom.Quiet> "2021" 这个数就代表了排列五个元素 (abcde), 取一个 a, 然后第二个 b
Zoom.Quiet> 放在 a 的右面成 ab, 取 c 放到最右面成为 abc, 取 d 放到最左面成
Zoom.Quiet> dabc; 最后 e 放到中间去成为 daebc. 至於 "2021"
Zoom.Quiet> 这个特别的设计的数可以用 ..+ x*4 + y*3 + z*2
Zoom.Quiet> 这样的计算来映对到自然数的数列上去. 

Zoom.Quiet> 没错了, 如求 4 个数的 4! = 24 个排列, 第 18
Zoom.Quiet> 个排列可以这样求得, 18 除 2, 余数是 0,
Zoom.Quiet> 所以第二个数放在第一个数的左面; 然后商 9 再除 3, 余数 0,
Zoom.Quiet> 所以第三个数於在头两个数的最左; 最后 3 除以 4, 余数是 3,
Zoom.Quiet> 因此第四个数要放在前三个数的第 4 个空位, 也就是最右面.
Zoom.Quiet> 利用这个方法, 你就不必先求出整个排列才能开始计算.
Zoom.Quiet> 尽管这好像牺牲了时间, 但省下了大量的空间. 你完全可以算出 1000
Zoom.Quiet> 个数的最大排列方法, 纵使那可能要用去几个月的运算.
Zoom.Quiet> 你更高兴的是用这个方法, 你可以把整个计算拆开成为一个一个的部份:
Zoom.Quiet> 譬如说求 10! = 3628800 个排列, 你大可以把 1 到 1000000
Zoom.Quiet> 让一部电脑做, 1000001 到 2000001 让另一部来做 ...
Zoom.Quiet> 大家的工作并不重覆, 这等於实现并行运算了! 啊哈! 妙极了!
Zoom.Quiet> """
Zoom.Quiet> 其实还是没有完全理解！


Zoom.Quiet> ps.
Zoom.Quiet> 仅仅得到数目，是没有办法进行详细的检验的，希望在下的愚昧可以作为最切实的最终验证！？

Zoom.Quiet> /******** [2004-04-27]12:01:15 ; you wrote:


Ye Tao>> ----- Original Message ----- 
Ye Tao>> From: "Zoom.Quiet" <zoomq at infopro.cn>
Ye Tao>> To: "Ye Tao" <python-chinese at lists.python.cn>
Ye Tao>> Sent: Tuesday, April 27, 2004 10:24 AM
Ye Tao>> Subject: Re[8]: [python-chinese] 趣味问题――号码分配


>>> Hollo Ye:
>>>
>>>   其实大家考虑的就两种思路：
>>> 1： 排除法：
>>> 先生成全部序列，然后排除不合题面儿的-- 算法？没有，思路简单，代码明晰，
>>> 虐待CPU；
>>>
>>> 2： 生成法：
>>> 分析正确的序列特性，直接生成，计数--- 算法可以有变化，数理要精确，代码复杂
Ye Tao>> ？优待CPU；
>>>
>>> 不过，看题，并没有要求输出所有正确的序列，只要数目，所以难以验证？
>>> 建议加一条！
>>> 输出所有序列到文件，并提供系统消耗对比！
>>>
>>> 在下先进行第一类，列举出所有正确的序列，作为正确答案？
>>> 然后，想象第三条路！
>>>
>>> 嗯嗯，同时建议为了快速进行，先玩6个球的情况吧？
>>>
Ye Tao>> 好的，拜托乐。。。



Zoom.Quiet> ********************************************/



********************************************/

-- 
Free as in Freedom

 Zoom.Quiet                           

#=========================================#
]Time is unimportant, only life important![
#=========================================#

sender is the Bat!2.02 CE