Statistik: kombinasi dengan Python

Saya perlu menghitung kombinatorial (nCr) dengan Python tetapi tidak dapat menemukan fungsi untuk melakukannya di math, numpyatau stat perpustakaan. Sesuatu seperti fungsi dari tipe:

comb = calculate_combinations(n, r)

Saya membutuhkan jumlah kombinasi yang mungkin, bukan kombinasi yang sebenarnya, jadi itertools.combinationssaya tidak tertarik.

Terakhir, saya ingin menghindari penggunaan faktorial, karena angka yang akan saya hitung kombinasinya bisa menjadi terlalu besar dan faktorialnya akan menjadi sangat besar.

Ini sepertinya pertanyaan yang BENAR-BENAR mudah dijawab, namun saya tenggelam dalam pertanyaan tentang menghasilkan semua kombinasi yang sebenarnya, yang bukan itu yang saya inginkan.

Lihat scipy.special.comb (scipy.misc.comb dalam versi scipy yang lebih lama). When exactis False, ia menggunakan fungsi gammaln untuk mendapatkan presisi yang baik tanpa menghabiskan banyak waktu. Dalam kasus yang tepat, ini mengembalikan bilangan bulat presisi arbitrer, yang mungkin membutuhkan waktu lama untuk dihitung.

Mengapa tidak menulisnya sendiri? Ini satu baris atau semacamnya:

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) )

Tes - mencetak segitiga Pascal:

>>> 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. diedit untuk diganti int(round(reduce(mul, (float(n-i)/(i+1) for i in range(k)), 1))) dengan int(reduce(mul, (Fraction(n-i, i+1) for i in range(k)), 1))sehingga tidak akan salah untuk N / K besar

Pencarian cepat di kode google memberikan (menggunakan rumus dari jawaban @Mark Byers ):

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()adalah 10 kali lebih cepat (diuji pada semua 0 <= (n, k) <1e3 pasangan) dibandingkan scipy.misc.comb()jika Anda membutuhkan jawaban yang tepat.

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

Jika Anda ingin hasil yang tepat dan kecepatan, coba gmpy - gmpy.combharus melakukan apa yang Anda minta, dan itu cukup cepat (tentu saja, sebagai gmpy's penulis asli, saya sedang bias ;-).

Jika Anda menginginkan hasil yang tepat, gunakan sympy.binomial. Tampaknya ini metode tercepat, tangan ke bawah.

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

Terjemahan literal dari definisi matematika cukup memadai dalam banyak kasus (mengingat bahwa Python akan secara otomatis menggunakan aritmatika angka besar):

from math import factorial

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

Untuk beberapa masukan yang saya uji (misalnya n = 1000 r = 500) ini lebih dari 10 kali lebih cepat daripada satu baris yang reducedisarankan dalam jawaban lain (saat ini dengan suara terbanyak). Di sisi lain, itu dilakukan oleh cuplikan yang disediakan oleh @JF Sebastian.

Memulai Python 3.8, pustaka standar sekarang menyertakan math.combfungsi untuk menghitung koefisien binomial:

math.comb (n, k)

yaitu banyaknya cara untuk memilih k item dari n item tanpa pengulangan
n! / (k! (n - k)!):

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

Berikut alternatif lain. Yang ini aslinya ditulis dalam C ++, sehingga dapat di-backport ke C ++ untuk integer presisi hingga (mis. __Int64). Keuntungannya adalah (1) hanya melibatkan operasi integer, dan (2) menghindari pembengkakan nilai integer dengan melakukan pasangan perkalian dan pembagian yang berurutan. Saya telah menguji hasilnya dengan segitiga Pascal Nas Banov, hasilnya benar:

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

Rasional: Untuk meminimalkan # perkalian dan pembagian, kami menulis ulang ekspresi sebagai

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

Untuk menghindari kelimpahan perkalian sebanyak mungkin, kami akan mengevaluasi dalam urutan STRICT berikut, dari kiri ke kanan:

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

Kita dapat menunjukkan bahwa aritmatika integer yang dioperasikan dalam urutan ini adalah tepat (yaitu tidak ada kesalahan pembulatan).

Menggunakan pemrograman dinamis, kompleksitas waktu adalah Θ (n * m) dan kompleksitas ruang Θ (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]

Jika program Anda memiliki batas atas n(katakanlah n <= N) dan perlu menghitung nCr berulang kali (sebaiknya untuk >> Nkali), menggunakan lru_cache dapat memberi Anda peningkatan kinerja yang besar:

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)

Membangun cache (yang dilakukan secara implisit) membutuhkan O(N^2)waktu. Setiap panggilan berikutnya ke nCrakan kembali masuk O(1).

Anda dapat menulis 2 fungsi sederhana yang ternyata sekitar 5-8 kali lebih cepat daripada menggunakan scipy.special.comb . Faktanya, Anda tidak perlu mengimpor paket tambahan apa pun, dan fungsinya cukup mudah dibaca. Triknya adalah dengan menggunakan memoization untuk menyimpan nilai yang dihitung sebelumnya, dan menggunakan definisi 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))

Jika kita membandingkan waktu

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

Sangat mudah dengan sympy.

import sympy

comb = sympy.binomial(n, r)

Hanya menggunakan pustaka standar yang didistribusikan dengan Python :

import itertools

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

Rumus langsung menghasilkan bilangan bulat besar jika n lebih besar dari 20.

Jadi, tanggapan lain:

from math import factorial

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

pendek, akurat dan efisien karena ini menghindari bilangan bulat besar python dengan bertahan dengan rindu.

Ini lebih akurat dan lebih cepat jika dibandingkan dengan 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

Ini adalah kode @ killerT2333 menggunakan dekorator memoisasi bawaan.

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))

Berikut adalah algoritma yang efisien untuk Anda

for i = 1.....r

   p = p * ( n - i ) / i

print(p)

Misalnya nCr (30,7) = fakta (30) / (fakta (7) * fakta (23)) = (30 * 29 * 28 * 27 * 26 * 25 * 24) / (1 * 2 * 3 * 4 * 5 * 6 * 7)

Jadi jalankan saja loop dari 1 ke r bisa mendapatkan hasilnya.

Itu mungkin secepat Anda bisa melakukannya dengan python murni untuk input yang cukup besar:

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

Fungsi ini sangat dioptimalkan.

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