【问题标题】:Statistics: combinations in Python统计:Python 中的组合
【发布时间】:2011-03-02 19:05:34
【问题描述】:

我需要在 Python 中计算组合 (nCr),但在 math、numpy 或 stat 库中找不到执行此操作的函数。类似于类型的函数:

comb = calculate_combinations(n, r)

我需要可能组合的数量,而不是实际组合,所以itertools.combinations 我不感兴趣。

最后,我想避免使用阶乘,因为我要计算组合的数字可能会变得太大,而阶乘会很可怕。

这似乎是一个非常容易回答的问题,但是我被关于生成所有实际组合的问题淹没了,这不是我想要的。

【问题讨论】:

    标签: python statistics combinations


    【解决方案1】:

    请参阅scipy.special.comb(旧版本 scipy 中的 scipy.misc.comb)。当exact 为 False 时,它​​使用 gammaln 函数来获得良好的精度,而不会花费太多时间。在确切的情况下,它返回一个任意精度的整数,这可能需要很长时间来计算。

    【讨论】:

    • scipy.misc.comb 已被弃用,取而代之的是 scipy.special.comb,因为版本为 0.10.0。
    【解决方案2】:

    为什么不自己写呢?这是一个单线或类似的:

    from operator import mul    # or mul=lambda x,y:x*y
    from fractions import Fraction
    
    def nCk(n,k): 
      return int( reduce(mul, (Fraction(n-i, i+1) for i in range(k)), 1) )
    

    测试 - 打印帕斯卡三角形:

    >>> for n in range(17):
    ...     print ' '.join('%5d'%nCk(n,k) for k in range(n+1)).center(100)
    ...     
                                                       1                                                
                                                    1     1                                             
                                                 1     2     1                                          
                                              1     3     3     1                                       
                                           1     4     6     4     1                                    
                                        1     5    10    10     5     1                                 
                                     1     6    15    20    15     6     1                              
                                  1     7    21    35    35    21     7     1                           
                               1     8    28    56    70    56    28     8     1                        
                            1     9    36    84   126   126    84    36     9     1                     
                         1    10    45   120   210   252   210   120    45    10     1                  
                      1    11    55   165   330   462   462   330   165    55    11     1               
                   1    12    66   220   495   792   924   792   495   220    66    12     1            
                1    13    78   286   715  1287  1716  1716  1287   715   286    78    13     1         
             1    14    91   364  1001  2002  3003  3432  3003  2002  1001   364    91    14     1      
          1    15   105   455  1365  3003  5005  6435  6435  5005  3003  1365   455   105    15     1   
        1    16   120   560  1820  4368  8008 11440 12870 11440  8008  4368  1820   560   120    16     1
    >>> 
    

    PS。编辑替换int(round(reduce(mul, (float(n-i)/(i+1) for i in range(k)), 1))) 使用int(reduce(mul, (Fraction(n-i, i+1) for i in range(k)), 1)),所以大 N/K 不会出错

    【讨论】:

    • +1 建议写一些简单的东西,使用 reduce,以及使用帕斯卡三角形的酷演示
    • -1 因为这个答案是错误的: print factorial(54)/(factorial(54 - 27))/factorial(27) == nCk(54, 27) 给出 False。
    • @robertking - 好的,你说得既小气又技术上是正确的。我所做的只是说明如何编写自己的函数;由于浮点精度,我知道对于足够大的 N 和 K 来说它是不准确的。但我们可以解决这个问题 - 见上文,现在它不应该因为大数字而犯错
    • 这在 Haskell 中可能会很快,但不幸的是 Python 不是。与许多其他答案相比,它实际上非常慢,例如@Alex Martelli、J.F. Sebastian 和我自己的。
    • 对于 Python 3,我还必须 from functools import reduce。
    【解决方案3】:

    快速搜索谷歌代码给出(它使用来自@Mark Byers's answer的公式):

    def choose(n, k):
        """
        A fast way to calculate binomial coefficients by Andrew Dalke (contrib).
        """
        if 0 <= k <= n:
            ntok = 1
            ktok = 1
            for t in xrange(1, min(k, n - k) + 1):
                ntok *= n
                ktok *= t
                n -= 1
            return ntok // ktok
        else:
            return 0
    

    如果您需要准确的答案,choose() 比scipy.misc.comb() 快 10 倍(在所有 0

    def comb(N,k): # from scipy.comb(), but MODIFIED!
        if (k > N) or (N < 0) or (k < 0):
            return 0L
        N,k = map(long,(N,k))
        top = N
        val = 1L
        while (top > (N-k)):
            val *= top
            top -= 1
        n = 1L
        while (n < k+1L):
            val /= n
            n += 1
        return val
    

    【讨论】:

    • 一个不错的解决方案,不需要任何 pkg
    • 仅供参考:这里提到的公式是:en.wikipedia.org/wiki/…
    • 这个choose 函数应该有更多的赞成票! Python 3.8 有 math.comb,但我不得不使用 Python 3.6 来应对挑战,并且没有一个实现给出了非常大整数的精确结果。这个做而且做的很快!
    【解决方案4】:

    如果您想要准确的结果和速度,请尝试gmpy -- gmpy.comb 应该完全符合您的要求,并且它非常快(当然,作为gmpy的原作者,我我有偏见;-)。

    【讨论】:

    • 事实上,gmpy2.comb() 比 choose() 快 10 倍,来自我对代码的回答:for k, n in itertools.combinations(range(1000), 2): f(n,k) 其中f() 在 Python 3 上是 gmpy2.comb() 或 choose()。跨度>
    • 既然你是包的作者,我会让你修复损坏的链接,让它指向正确的地方......
    • @SeldomNeedy,code.google.com 的链接是一个正确的位置(尽管该网站现在处于存档模式)。当然,从那里很容易找到 github 位置 github.com/aleaxit/gmpy 和 PyPI 位置 pypi.python.org/pypi/gmpy2 ,因为它链接到两者!-)
    • @AlexMartelli 很抱歉造成混乱。如果 javascript 已(选择性地)禁用,该页面将显示 404。我想这是为了阻止流氓 AI 如此轻易地合并存档的 Google 代码项目源?
    • 向您推荐,这是我在回答中测试的 17 种不同算法中最快的。太糟糕了,它不支持分数/小数。
    【解决方案5】:

    如果您想要准确的结果,请使用sympy.binomial。这似乎是最快的方法,放心吧。

    x = 1000000
    y = 234050
    
    %timeit scipy.misc.comb(x, y, exact=True)
    1 loops, best of 3: 1min 27s per loop
    
    %timeit gmpy.comb(x, y)
    1 loops, best of 3: 1.97 s per loop
    
    %timeit int(sympy.binomial(x, y))
    100000 loops, best of 3: 5.06 µs per loop
    

    【讨论】:

    • sympy 有一个缓存,它的 timeit 没有清除。在我的测试中,gmpy 的速度快了约 264 倍。
    【解决方案6】:

    在很多情况下,数学定义的直译就足够了(记住 Python 会自动使用大数算术):

    from math import factorial
    
    def calculate_combinations(n, r):
        return factorial(n) // factorial(r) // factorial(n-r)
    

    对于我测试的某些输入(例如 n=1000 r=500),这比另一个(当前投票最高的)答案中建议的一个衬垫 reduce 快 10 倍以上。另一方面,它的表现优于@J.F. 提供的代码片段。塞巴斯蒂安。

    【讨论】:

      【解决方案7】:

      从 Python 3.8 开始,标准库现在包含 math.comb 函数来计算二项式系数:

      math.comb(n, k)

      这是从n个项目中选择k个项目而不重复的方法数
      n! / (k! (n - k)!):

      import math
      math.comb(10, 5) # 252
      

      【讨论】:

        【解决方案8】:

        这是另一种选择。这个最初是用 C++ 编写的,因此它可以向后移植到 C++ 以获取有限精度整数(例如 __int64)。优点是(1)它只涉及整数运算,(2)它通过连续成对的乘法和除法来避免使整数值膨胀。我用 Nas Banov 的帕斯卡三角形测试了结果,它得到了正确的答案:

        def choose(n,r):
          """Computes n! / (r! (n-r)!) exactly. Returns a python long int."""
          assert n >= 0
          assert 0 <= r <= n
        
          c = 1L
          denom = 1
          for (num,denom) in zip(xrange(n,n-r,-1), xrange(1,r+1,1)):
            c = (c * num) // denom
          return c
        

        基本原理:为了最小化乘法和除法的次数,我们将表达式重写为

            n!      n(n-1)...(n-r+1)
        --------- = ----------------
         r!(n-r)!          r!
        

        为尽可能避免乘法溢出,我们将按照以下 STRICT 顺序进行计算,从左到右:

        n / 1 * (n-1) / 2 * (n-2) / 3 * ... * (n-r+1) / r
        

        我们可以证明以这个顺序进行的整数运算是精确的(即没有舍入误差)。

        【讨论】:

          【解决方案9】:

          您可以编写 2 个简单的函数,它们实际上比使用 scipy.special.comb 快 5-8 倍。实际上,您不需要导入任何额外的包,并且该功能非常易于阅读。诀窍是使用记忆来存储先前计算的值,并使用nCr的定义

          # create a memoization dictionary
          memo = {}
          def factorial(n):
              """
              Calculate the factorial of an input using memoization
              :param n: int
              :rtype value: int
              """
              if n in [1,0]:
                  return 1
              if n in memo:
                  return memo[n]
              value = n*factorial(n-1)
              memo[n] = value
              return value
          
          def ncr(n, k):
              """
              Choose k elements from a set of n elements - n must be larger than or equal to k
              :param n: int
              :param k: int
              :rtype: int
              """
              return factorial(n)/(factorial(k)*factorial(n-k))
          

          如果我们比较时间

          from scipy.special import comb
          %timeit comb(100,48)
          >>> 100000 loops, best of 3: 6.78 µs per loop
          
          %timeit ncr(100,48)
          >>> 1000000 loops, best of 3: 1.39 µs per loop
          

          【讨论】:

          • 现在 functools 中有一个名为 lru_cache 的 memoize 装饰器,它可能会简化你的代码?
          【解决方案10】:

          使用动态规划,时间复杂度为Θ(n*m),空间复杂度为Θ(m):

          def binomial(n, k):
          """ (int, int) -> int
          
                   | c(n-1, k-1) + c(n-1, k), if 0 < k < n
          c(n,k) = | 1                      , if n = k
                   | 1                      , if k = 0
          
          Precondition: n > k
          
          >>> binomial(9, 2)
          36
          """
          
          c = [0] * (n + 1)
          c[0] = 1
          for i in range(1, n + 1):
              c[i] = 1
              j = i - 1
              while j > 0:
                  c[j] += c[j - 1]
                  j -= 1
          
          return c[k]
          

          【讨论】:

            【解决方案11】:

            如果你的程序有一个上限为n(比如n &lt;= N)并且需要重复计算nCr(最好是>>N次),使用lru_cache可以给你带来巨大的性能提升:

            from functools import lru_cache
            
            @lru_cache(maxsize=None)
            def nCr(n, r):
                return 1 if r == 0 or r == n else nCr(n - 1, r - 1) + nCr(n - 1, r)
            

            构造缓存(隐式完成)最多需要O(N^2) 时间。对nCr 的任何后续调用都将返回O(1)。

            【讨论】:

              【解决方案12】:

              使用 sympy 很容易。

              import sympy
              
              comb = sympy.binomial(n, r)
              

              【讨论】:

              • 这个的好处是它是我能找到的唯一一个支持 n/r 为浮点数且 n 为负数的 python 二项式函数。另一个答案说它很快,但我敢打赌它正在做某种形式的缓存。
              【解决方案13】:

              仅使用随 Python 分发的标准库:

              import itertools
              
              def nCk(n, k):
                  return len(list(itertools.combinations(range(n), k)))
              

              【讨论】:

              • 我不认为它的时间复杂度(和内存使用)是可以接受的。
              【解决方案14】:

              当 n 大于 20 时,直接公式产生大整数。

              所以,又是一个回应:

              from math import factorial
              
              reduce(long.__mul__, range(n-r+1, n+1), 1L) // factorial(r)
              

              简短、准确和高效,因为这通过坚持 long 来避免 python 大整数。

              与 scipy.special.comb 相比,它更准确、更快:

               >>> from scipy.special import comb
               >>> nCr = lambda n,r: reduce(long.__mul__, range(n-r+1, n+1), 1L) // factorial(r)
               >>> comb(128,20)
               1.1965669823265365e+23
               >>> nCr(128,20)
               119656698232656998274400L  # accurate, no loss
               >>> from timeit import timeit
               >>> timeit(lambda: comb(n,r))
               8.231969118118286
               >>> timeit(lambda: nCr(128, 20))
               3.885951042175293
              

              【讨论】:

              • 这是错误的!如果 n == r,则结果应为 1。此代码返回 0。
              • 更准确地说,应该是range(n-r+1, n+1),而不是range(n-r,n+1)。
              【解决方案15】:

              这个功能非常优化。

              def nCk(n,k):
                  m=0
                  if k==0:
                      m=1
                  if k==1:
                      m=n
                  if k>=2:
                      num,dem,op1,op2=1,1,k,n
                      while(op1>=1):
                          num*=op2
                          dem*=op1
                          op1-=1
                          op2-=1
                      m=num//dem
                  return m
              

              【讨论】:

                【解决方案16】:

                对于相当大的输入,这可能与纯 python 中的速度一样快:

                def choose(n, k):
                    if k == n: return 1
                    if k > n: return 0
                    d, q = max(k, n-k), min(k, n-k)
                    num =  1
                    for n in xrange(d+1, n+1): num *= n
                    denom = 1
                    for d in xrange(1, q+1): denom *= d
                    return num / denom
                

                【讨论】:

                  【解决方案17】:

                  这里有一个适合你的高效算法

                  for i = 1.....r
                  
                     p = p * ( n - i ) / i
                  
                  print(p)
                  

                  例如 nCr(30,7) = 事实(30) / ( 事实(7) * 事实(23)) = ( 30 * 29 * 28 * 27 * 26 * 25 * 24 ) / (1 * 2 * 3 * 4 * 5 * 6 * 7)

                  所以只要从 1 到 r 循环运行就可以得到结果。


                  在python中:

                  n,r=5,2
                  p=n
                  for i in range(1,r):
                     p = p*(n - i)/i
                  else:
                     p = p/(i+1)
                  print(p)
                  

                  【讨论】:

                    【解决方案18】:

                    我从这个线程和这里链接的库中计时了 17 个不同的函数。

                    Since I feel it's a bit much to dump here, I put the code for the functions in a pastebin here.

                    我做的第一个测试是将帕斯卡的三角形构建到第 100 行。我用 timeit 做了 100 次。下面的数字是构建一次三角形所需的平均时间(以秒为单位)。

                    gmpy2.gmpy2.comb 0.0012259269999998423
                    math.comb 0.007063110999999935
                    __main__.stdfactorial2 0.011469491
                    __main__.scipybinom 0.0120114319999999
                    __main__.stdfactorial 0.012105122
                    __main__.scipycombexact 0.012569045999999844
                    __main__.andrewdalke 0.01825201100000015
                    __main__.rabih 0.018472497000000202
                    __main__.kta 0.019374668000000383
                    __main__.wirawan 0.029312811000000067
                    scipy.special._basic.comb 0.03221609299999954
                    __main__.jfsmodifiedscipy 0.04332894699999997
                    __main__.rojas 0.04395155400000021
                    sympy.functions.combinatorial.factorials.binomial 0.3233529779999998
                    __main__.nasbanov 0.593365528
                    __main__.pantelis300 1.7780402499999999
                    

                    您可能会注意到这里只有 16 个函数。那是因为recursive() 函数甚至无法在合理的时间内完成一次,所以我不得不将它从 timeit 测试中排除。说真的,已经持续了好几个小时了。

                    我还计时了并非所有上述功能都支持的各种其他类型的输入。请记住,我只运行了每 10 次测试,因为 nCr 的计算量很大而且我很不耐烦

                    n 的小数值

                    __main__.scipybinom 0.011481370000000001
                    __main__.kta 0.01869513999999999
                    sympy.functions.combinatorial.factorials.binomial 6.33897291
                    

                    r 的小数值

                    __main__.scipybinom 0.010960040000000504
                    scipy.special._basic.comb 0.03681254999999908
                    sympy.functions.combinatorial.factorials.binomial 3.2962564499999987
                    

                    n 和 r 的小数值

                    __main__.scipybinom 0.008623409999998444
                    sympy.functions.combinatorial.factorials.binomial 3.690936439999999
                    

                    n 的负值

                    gmpy2.gmpy2.comb 0.010770989999997482
                    __main__.kta 0.02187850000000253
                    __main__.rojas 0.05104292999999984
                    __main__.nasbanov 0.6153183200000001
                    sympy.functions.combinatorial.factorials.binomial 3.0460310799999943
                    

                    n 为负小数值,r 为小数值

                    sympy.functions.combinatorial.factorials.binomial 3.7689941699999965
                    

                    目前实现最大速度和多功能性的最佳解决方案是混合函数,根据输入在不同算法之间进行选择

                    def hybrid(n: typing.Union[int, float], k: typing.Union[int, float]) -> typing.Union[int, float]:
                        # my own custom hybrid solution
                        def is_integer(n):
                            return isinstance(n, int) or n.is_integer()
                        if k < 0:
                            raise ValueError("k cannot be negative.")
                        elif n == 0:
                            return 0
                        elif k == 0 or k == n:
                            return 1
                        elif is_integer(n) and is_integer(k):
                            return int(gmpy2.comb(int(n), int(k)))
                        elif n > 0:
                            return scipy.special.binom(n, k)
                        else:
                            return float(sympy.binomial(n, k))
                    

                    由于sympy.binomial() 如此缓慢,真正理想的解决方案是将scipy.special.binom() 的代码组合起来,它对分数表现良好,gmpy2.comb() 对整数表现良好。 scipy's func 和 gympy2's func 都是用我不太熟悉的 C 语言编写的。

                    【讨论】:

                      【解决方案19】:

                      这是使用内置记忆装饰器的@killerT2333 代码。

                      from functools import lru_cache
                      
                      @lru_cache()
                      def factorial(n):
                          """
                          Calculate the factorial of an input using memoization
                          :param n: int
                          :rtype value: int
                          """
                          return 1 if n in (1, 0) else n * factorial(n-1)
                      
                      @lru_cache()
                      def ncr(n, k):
                          """
                          Choose k elements from a set of n elements,
                          n must be greater than or equal to k.
                          :param n: int
                          :param k: int
                          :rtype: int
                          """
                          return factorial(n) / (factorial(k) * factorial(n - k))
                      
                      print(ncr(6, 3))
                      

                      【讨论】:

                        猜你喜欢
                        • 1970-01-01
                        • 1970-01-01
                        • 1970-01-01
                        • 2014-04-10
                        • 2016-07-18
                        • 2014-10-01
                        • 2018-01-24
                        • 2015-07-18
                        • 1970-01-01
                        相关资源
                        最近更新 更多