Escreva um programa que leia dois inteiros m e n e calcula o coeficiente binomial
m!/(n!(m-n)!)
ou seja, um programa que calcule quantas formas distintas é possível escolher n elementos de um grupo de m elementos.
def main():
"""
primeira versão do programa que calcula m! / (n! (m - n)!)
"""
print("Cálculo de binomial(m, n)")
m = int(input("Digite o valor de m:"))
n = int(input("Digite o valor de n:"))
fatm = 1
cont = 1
while cont <= m:
fatm *= cont
cont += 1
fatn = 1
cont = 1
while cont <= n:
fatn *= cont
cont += 1
fatmn = 1
cont = 1
while cont <= (m-n):
fatmn *= cont
cont += 1
binomial = fatm / (fatn * fatmn)
print ("binomial(%d, %d) = %d" %(m, n, binomial))
# início da execução do programa
main()
def main():
"""
Segunda versão do programa que calcula m! / (n! (m - n)!)
(usando a função fatorial)
"""
print("Calculo de binomial(m, n)")
m = int(input("Digite o valor de m:"))
n = int(input("Digite o valor de n:"))
binomial = fatorial(m) / (fatorial(n) * fatorial(m-n))
print ("Binomial(%d, %d) = %d" %(m, n, binomial))
#-----------------------------------------------------
def fatorial(k):
'''(int) -> int
Recebe um inteiro k e retorna o valor de k!
Pre-condicao: supõe que k é um número inteiro não negativo.
'''
k_fat = 1
i = 2
while i <= k:
k_fat *= i
i += 1
return k_fat
# início da execução do programa
main()
def main():
"""
Terceira versão do programa que calcula m! / (n! (m - n)!)
(usando as funções binomial e fatorial)
"""
print("Calculo de binomial(m, n)")
m = int(input("Digite o valor de m:"))
n = int(input("Digite o valor de n:"))
print ("binomial(%d, %d) = %d" %(m, n, binomial(m,n)))
#-----------------------------------------------------
def binomial(m,n):
'''(int,int) -> int
Recebe dois inteiros m e n e retorna o valor da
combinacao de m n-a-n.
Utiliza a função fatorial().
Pré-condição: supõe que m e n são números inteiros não negativos.
'''
return fatorial(m)/(fatorial(m-n)*fatorial(n))
#-----------------------------------------------------
def fatorial(k):
'''(int) -> int
Recebe um inteiro k e retorna o valor de k!
Pre-condicao: supõe que k é um número inteiro não negativo.
'''
k_fat = 1
i = 2
while i <= k:
k_fat *= i
i += 1
return k_fat
# início da execução do programa
main()
Logo no início das funções main, fat e binomial que criamos, é possível ver um comentário de bloco. Esse tipo de comentário no início de uma função é chamado de docstring, e seu objetivo é documentar a função.
Um docstring deve conter a informação que é essencial de se saber para alguém que quer usar a função. Ele deve explicar de forma concisa o quê a função faz, mas sem entrar em detalhes sobre como isso é feito. Ele deve dizer o significado de cada parâmetro de entrada e também o seu tipo esperado (quando necessário). O docstring deve dizer também o que a função devolve como valor de retorno.
Podemos ver o docstring de uma função usando a função help, como no exemplo abaixo:
help(fatorial)
Faça um programa que lê um numero inteiro n > 0 e imprime os coeficientes da expansão de (a+b)n .
def main():
"""
Programa que mostra os coeficientes de (a + b) ** n
"""
print("Cálculo dos coeficientes de (a + b) ** n")
n = int(input("Digite o valor de n:"))
p = 0
while p <= n:
print("coef do termo a^(%d).b^(%d) = %d" %(n-p, p, binomial(n, p)))
p += 1
#-----------------------------------------------------
def binomial(m,n):
'''(int,int) -> int
Recebe dois inteiros m e n e retorna o valor da
combinacao de m n-a-n.
Utiliza a função fatorial().
Pré-condição: supõe que m e n são números inteiros não negativos.
'''
return fatorial(m)/(fatorial(m-n)*fatorial(n))
#-----------------------------------------------------
def fatorial(k):
'''(int) -> int
Recebe um inteiro k e retorna o valor de k!
Pre-condicao: supõe que k é um número inteiro não negativo.
'''
k_fat = 1
i = 2
while i <= k:
k_fat *= i
i += 1
return k_fat
# início da execução do programa
main()
Faça um programa que lê um numero inteiro n > 0 e imprime as n primeiras linhas do triângulo de Pascal.
def main():
"""
Programa que imprime as n primeiras linhas do triângulo de Pascal
"""
n = int(input("Digite o valor de n: "))
i = 0
while i < n:
p = 0
while p <= i: # Observe que este laço está dentro de outro laço!!!
print(binomial(i,p), end = "\t")
p += 1
i += 1
print()
#-----------------------------------------------------
def binomial(m,n):
'''(int,int) -> int
Recebe dois inteiros m e n e retorna o valor da
combinacao de m n-a-n.
Utiliza a função fatorial().
Pré-condição: supõe que m e n são números inteiros não negativos.
'''
return fatorial(m)/(fatorial(m-n)*fatorial(n))
#-----------------------------------------------------
def fatorial(k):
'''(int) -> int
Recebe um inteiro k e retorna o valor de k!
Pre-condicao: supõe que k é um número inteiro não negativo.
'''
k_fat = 1
i = 2
while i <= k:
k_fat *= i
i += 1
return k_fat
# início da execução do programa
main()
def e returndocstring