Coefficient binomial python

import math
x = int(input("Enter a value for x: "))
y = int(input("Enter a value for y: "))

if y == 1 or y == x:
    print(1)

if y > x:
    print(0)        
else:
    a = math.factorial(x)
    b = math.factorial(y)
    div = a // (b*(x-y))
    print(div)

Ce binôme coeeficient programme fonctionne mais quand je saisie deux fois le même nombre, ce qui est supposé égal à 1 ou si y est supérieur à x, il est supposé égal à 0. le programme a besoin d'un peu de peaufinage si quelqu'un peut m'aider

source d'informationauteur user3396351

python python-3.x

Votre programme va continuer avec le deuxième if déclaration en cas de y == xprovoquant une ZeroDivisionError. Vous avez besoin de faire les déclarations mutuellement exclusives; la façon de le faire est d'utiliser elif ("else if") au lieu de if:

import math
x = int(input("Enter a value for x: "))
y = int(input("Enter a value for y: "))
if y == x:
    print(1)
elif y == 1:         # see georg's comment
    print(x)
elif y > x:          # will be executed only if y != 1 and y != x
    print(0)
else:                # will be executed only if y != 1 and y != x and x <= y
    a = math.factorial(x)
    b = math.factorial(y)
    c = math.factorial(x-y)  # that appears to be useful to get the correct result
    div = a // (b * c)
    print(div)

54

Cette question est vieux, mais comme elle vient de haut sur les résultats de la recherche je ferai remarquer que, scipy a un coefficient binomial fonction:
```
import scipy.special
scipy.special.binom(10, 5)
```
(Voir la documentation.)

Voici une version qui utilise le formule correcte . 🙂

#! /usr/bin/env python

''' Calculate binomial coefficient xCy = x! /(y! (x-y)!)
'''

from math import factorial as fac


def binomial(x, y):
    try:
        binom = fac(x) // fac(y) // fac(x - y)
    except ValueError:
        binom = 0
    return binom


#Print Pascal's triangle to test binomial()
def pascal(m):
    for x in range(m + 1):
        print([binomial(x, y) for y in range(x + 1)])


def main():
    #input = raw_input
    x = int(input("Enter a value for x: "))
    y = int(input("Enter a value for y: "))
    print(binomial(x, y))


if __name__ == '__main__':
    #pascal(8)
    main()

...

Voici une version alternative de binomial() j'ai écrit il y a plusieurs années qui n'utilise pas math.factorial()qui n'existait pas dans les anciennes versions de Python. Toutefois, elle renvoie 1 si r n'est pas in range(0, n+1).

def binomial(n, r):
    ''' Binomial coefficient, nCr, aka the "choose" function 
        n! /(r! * (n - r)!)
    '''
    p = 1    
    for i in xrange(1, min(r, n - r) + 1):
        p *= n
        p //= i
        n -= 1
    return p

Donc, cette question revient tout d'abord si vous la recherche pour "mettre en Œuvre des coefficients binomiaux dans Python". Seulement cette réponse dans sa deuxième partie contient une mise en œuvre efficace qui s'appuie sur la multiplicatif de formule. Cette formule effectue au strict minimum le nombre de multiplications. La fonction ci-dessous ne dépend pas d'une built-ins ou des importations:

def fcomb0(n, k):
    '''
    Compute the number of ways to choose k elements out of a pile of n.

    Use an iterative approach with the multiplicative formula:
    \frac{n!}{k!(n - k)!} =
    \frac{n(n - 1)\dots(n - k + 1)}{k(k-1)\dots(1)} =
    \prod{i = 1}{k}\frac{n + 1 - i}{i}

    Also rely on the symmetry: C_n^k = C_n^{n - k}, so the product can
    be calculated up to min(k, n - k)

    :param n: the size of the pile of elements
    :param k: the number of elements to take from the pile
    :return: the number of ways to choose k elements out of a pile of n
    '''

    # When k out of sensible range, should probably throw an exception.
    # For compatibility with scipy.special.{comb, binom} returns 0 instead.
    if k < 0 or k > n:
        return 0

    if k == 0 or k == n:
        return 1

    total_ways = 1
    for i in range(min(k, n - k)):
        total_ways = total_ways * (n - i) // (i + 1)

    return total_ways

Enfin, si vous avez besoin d'encore plus de valeurs et n'ont pas l'esprit de négociation certaine précision, Stirling rapprochement est probablement la voie à suivre.

2

Pour Python 3, scipy a la fonction scipy.spécial.peigne, ce qui peut produire à virgule flottante ainsi que entier exact résultats
```
import scipy.special

res = scipy.special.comb(x, y, exact=True)
```
Consultez la documentation de scipy.spécial.peigne.

Pour Python 2, la fonction se trouve dans scipy.misc, et il fonctionne de la même manière:
```
import scipy.misc

res = scipy.misc.comb(x, y, exact=True)
```

Ce sujet de celui-ci? 🙂 Il utilise la formule correcte, évite math.factorial et prend moins les opérations de multiplication:

import math
import operator
product = lambda m,n: reduce(operator.mul, xrange(m, n+1), 1)
x = max(0, int(input("Enter a value for x: ")))
y = max(0, int(input("Enter a value for y: ")))
print product(y+1, x) / product(1, x-y)

Aussi, afin d'éviter les grands-entier arithmétique, vous pouvez utiliser des nombres à virgule flottante, convertir
product(a[i])/product(b[i]) à product(a[i]/b[i]) et de réécrire le programme ci-dessus:

import math
import operator
product = lambda iterable: reduce(operator.mul, iterable, 1)
x = max(0, int(input("Enter a value for x: ")))
y = max(0, int(input("Enter a value for y: ")))
print product(map(operator.truediv, xrange(y+1, x+1), xrange(1, x-y+1)))

Ici est une fonction récursive qui calcule les coefficients binomiaux à l'aide d'expressions conditionnelles

def binomial2(n,k):
    return 1 if k==0 else (0 if n==0 else binomial(n-1, k) + binomial(n-1, k-1))

Vous devez vous connecter pour publier un commentaire.