def mnogokanal_SMO_otkaz():
potokZav = float(potokZavE.get()) # lambda
tAverage = float(tAverageE.get()) # Среднее время обслуживания в Часах
n = int(nE.get()) # Количество каналов
potokObs = (1 / tAverage) # Интенсивонсть потока обслуживания U
p = potokZav / potokObs # Нагрузка системы
p_rotv = round(p, 3)
p0 = 0
for c in range(n + 1):
p0 += (p**c / fc(c))
p0 = round((1 / p0), 3) # Вероятность простоя системы
p1 = round(((p**n / fc(n)) * p0), 3) # Вероятность отказа
Q = round((1 - p1), 3) # относительная пропускная способность
A = round((potokZav * Q), 3) # абсолютная пропускная способность
n_z = round((p * Q), 3) # Число каналов занятый обслуживанием
k_z = round((n_z / n), 3) # Коэффициент занятости каналов
T_smo = round((n_z / potokZav),
3) # Среднее время пребывания заявки в системе
T_ob = round((1 / potokObs),
3) # Ср. время обслуживанияканалом одной заявки
potokObs = round(potokObs, 3)
return (pE.set(p_rotv), P0E.set(p0), P1E.set(p1), QE.set(Q), AE.set(A),
n_zE.set(n_z), k_zE.set(k_z), T_smoE.set(T_smo), T_obE.set(T_ob),
potokObsE.set(potokObs))
def mnogokanal_SMO_bez():
potokZav = float(potokZavE.get()) # lambda
tAverage = float(tAverageE.get()) # Среднее время обслуживания в Часах
n = int(nE.get()) # Количество каналов
potokObs = (1 / tAverage) # Интенсивонсть потока обслуживания U
p = potokZav / potokObs # Нагрузка системы
p_rotv = round(p, 3)
g = 1
p_start = 0
for i in range(n):
p_start += p**n / fc(n)
g += 1
p0 = round((1 / (1 + p_start + ((p**(n + 1)) / (fc(n) * (n - p))))), 3)
p_och = round((((p**(n + 1)) / (fc(n) * (n - p))) * p0), 3)
L_och = round((n / (n - p)) * p_och, 3)
T_och = round((L_och / potokZav), 3)
T_smo = round((T_och + tAverage), 3)
p1 = '0 %'
Q = 1
A = round((potokZav * Q), 3)
n_z = round(p, 3)
n_pr = round((n - n_z), 3)
k_z = round(n_z / n, 3)
potokObs = round(potokObs, 3)
return (pE.set(p_rotv), P0E.set(p0), P1E.set(p1), QE.set(Q), AE.set(A),
n_zE.set(n_z), n_prE.set(n_pr), L_ochE.set(L_och),
T_ochE.set(T_och), T_smoE.set(T_smo), k_zE.set(k_z),
potokObsE.set(potokObs))
def getDiffQuotientTab(self):
"""Generate a matrix which represents the difference quotient table
of (x_known, y_known).
"""
equidistant = False # equidistant is false by defualt
t = self.x[1] - self.x[0]
for i in range(1, len(self.x) - 1):
if round(t, 1) == round(self.x[i + 1] - self.x[i], 1):
equidistant = True
else:
equidistant = False
break
if equidistant == False:
n = len(self.x) - 1
ans = [[None for i in range(n)] for i in range(n)]
# initialize it with default setting None.
for i in range(n): # column
for j in range(i, n): # row
if i == 0:
ans[j][i] = (self.y[j+1] - self.y[j]) \
/ (self.x[j+1] - self.x[j])
else:
ans[j][i] = (ans[j][i-1] - ans[j-1][i-1]) \
/ (self.x[j+1] - self.x[j-1])
pass
return ans
else:
from math import factorial as fc
from math import pow as pow
n = len(self.x) - 1
ans = [[None for i in range(n)] for i in range(n)]
diffTab = self.getDiffTab()
for i in range(n):
low = fc(i + 1) * pow(t, i + 1)
up = diffTab[i][i]
ans[i][i] = up / low
return ans
def factorial(n):
if n < 0 or n > 12:
raise ValueError
return fc(n)
def mnogokanal_SMO_dlina_ocheredi():
potokZav = float(potokZavE.get()) # lambda
tAverage = float(tAverageE.get()) # Среднее время обслуживания в Часах
n = int(nE.get()) # Количество каналов
potokObs = (1 / tAverage) # Интенсивонсть потока обслуживания U
nagruzka_m = int(nagruzka_mE.get()) # Длина очереди
mid = 0
p = potokZav / potokObs # Нагрузка системы
p_rotv = round(p, 3)
if p / n == 1:
# ch = 1
# while n-1 != ch:
# mid += (p ** ch / fc(ch))
# ch += 1
ch = 1
for ii in range(n):
mid += (p**ch / fc(ch))
ch += 1
last = (nagruzka_m * p**(n + 1)) / (n * fc(n))
p0 = round((1 + mid + last)**-1, 3) # Вероятность простоя
pn = round(
(p**n / fc(n)) * p0, 3
) # Вероятность того, что в СМО находится какое-либо кол-во заявок
try:
p_och = round((p**n / (fc(n))) * ((1 - ((p / n)**nagruzka_m)) /
(1 - (p / n))) * p0,
3) # Вероятность образования очереди
p_ochE.set(p_och)
except:
print('Error')
p1 = round(((p**(n + nagruzka_m)) / (n**nagruzka_m * fc(n))) * p0,
3) # Вероятность отказа
Q = round((1 - p1), 3) # Относительная пропускная способность
A = round((potokZav * Q), 3) # Абсолютная пропускная способность
n_z = round((p * Q), 3) # Ср. Число каналов занятый обслуживанием
n_pr = round((n - n_z), 3) # Ср. Число простаивающих каналов
L_och = round((((p**(n + 1)) / (n * fc(n))) *
(nagruzka_m * (nagruzka_m + 1)) / 2 * p0),
3) # Ср. число заявок, стоящий в очереди
T_och = round((L_och / potokZav),
3) # Среднее время ожидания обслужвания
T_smo = round((L_och / potokZav) + (Q / potokObs),
3) # Среднее время пребывания заявки в системе
k_z = round(n_z / n, 3) # Коэффициент занятости каналов
k_pr = round(1 - k_z, 3) # Коэффициент простоя каналов
L_ob = round(p * Q, 3) # Ср.число заявок, находящихся на обслуживании
L_smo = round(L_och + L_ob,
3) # Ср. число завяок, находящихся в системе
pE.set(p_rotv),
P0E.set(p0),
PnE.set(pn),
P1E.set(p1),
QE.set(Q),
AE.set(A),
n_zE.set(n_z),
n_prE.set(n_pr),
L_ochE.set(L_och),
T_ochE.set(T_och),
T_smoE.set(T_smo),
k_zE.set(k_z),
k_prE.set(k_pr),
L_obE.set(L_ob),
L_smoE.set(L_smo),
potokObsE.set(potokObs)
else:
start = 0
for i in range(n + 1):
start += (p**i / fc(i))
p0 = round(
1 / (start + ((p**(n + 1) / (fc(n) * (n - p))) *
(1 - ((p / n)**nagruzka_m)))), 3)
try:
p_och = round(((p**n / (fc(n))) * ((1 - ((p / n)**nagruzka_m)) /
(1 - (p / n))) * p0),
3) # Вероятность образования очереди
p_ochE.set(p_och)
except:
print('Error')
L_och = round(
(((p**(n + 1)) / (n * fc(n))) *
(1 - (p / n)**nagruzka_m * (nagruzka_m + 1 - nagruzka_m *
(p / n))) / ((1 - p / n)**2) * p0), 3)
T_och = round((L_och / potokZav), 3)
# p1 = (p ** (n + nagruzka_m) / n ** nagruzka_m * fc(n)) * p0
p1 = round((((p**(n + nagruzka_m)) / (n**nagruzka_m * fc(n))) * p0), 3)
Q = round((1 - p1), 3)
A = round((potokZav * Q), 3)
n_z = round((p * Q), 3) # Число каналов занятый обслуживанием
n_pr = round((n - n_z), 3) # Ср. Число простаивающих каналов
k_z = round((n_z / n),
3) # Коэффициент занятости каналов обслуживанием
k_pr = round((1 - k_z), 3) # Коэффициент простоя каналов
L_ob = round((p * Q),
3) # Ср.число заявок, находящихся на обслуживании
L_smo = round((L_och + L_ob),
3) # Ср. число завяок, находящихся в системе
T_smo = round((L_smo / A), 3)
print(p)
print(p0)
print(nagruzka_m)
print(n)
return (pE.set(p_rotv), P0E.set(p0), P1E.set(p1), QE.set(Q), AE.set(A),
n_zE.set(n_z), n_prE.set(n_pr), L_ochE.set(L_och),
T_ochE.set(T_och), T_smoE.set(T_smo), k_zE.set(k_z),
k_prE.set(k_pr), L_obE.set(L_ob), L_smoE.set(L_smo),
potokObsE.set(potokObs))
def s6j(a,b,c,d,e,f):
from math import factorial as fc
from math import sqrt
trangle = lambda a,b,c : a-b<=c<=a+b
delta = lambda a,b,c : sqrt(fc(a+b-c)*fc(a-b+c)*fc(-a+b+c)/fc(a+b+c+1))
if (not trangle(a,b,c)) or (not trangle(c,d,e)) or (not trangle(a,e,f)) or (not trangle(b,c,f)):
return 0
summ = 0
n = 0
while n < a+b+c+d+e+f:
if (n-a-b-c) < 0 or\
(n-c-d-e) < 0 or\
(n-a-e-f) < 0 or\
(n-b-d-f) < 0 or\
(a+b+d+e-n) < 0 or\
(a+c+d+f-n) < 0 or\
(b+c+e+f-n) < 0:
n+=1
continue
summ+=(-1)**n*fc(n+1)/(fc(n-a-b-c)*fc(n-c-d-e)*fc(n-a-e-f)*fc(n-b-d-f)\
*fc(a+b+d+e-n)*fc(a+c+d+f-n)*fc(b+c+e+f-n))
n+=1
print(n)
summ*=delta(a,b,c)*delta(c,d,e)*delta(a,e,f)*delta(b,d,f)
return summ
def fastest_route(m, n):
return fc(m + n) / (fc(m) * fc(n))
def choose(n, k):
if n < k:
return 0
else:
return int(fc(n) // (fc(k) * fc(n - k)))
def choose(n, k):
return fc(n) / (fc(k) * fc(n - k))
def debye_function_exp(self, x):
Brillouin = [1./6.,-1./30.,1./42.,-1./30.,5./66.,-691./2730.,7./6.,-3617./510.,43867./798,-174611./330.]
D2=0.
for k in range(len(Brillouin)):
D2 = D2+Brillouin[k]/( (2*(k+1)+3)*fc(2*(k+1)) )*x**(2*(k+1))
return 1- 3./8.*x + 3*D2
from math import factorial as fc
print(fc(1000))
import sys
from pprint import pprint as pp
pp([
sys.float_info, sys.int_info, sys.hash_info, sys.thread_info,
sys.version_info, sys.version, sys.api_version
])
most_negative_float = -sys.float_info.max
greatest_negative_float = -sys.float_info.min
pp((most_negative_float, greatest_negative_float))
pp(float("10"))
pp(2**53)
pp(float(2**53)) # Correct
pp(float(2**53 + 1)) # Incorrect
pp(float(2**53 + 2)) # Correct
pp(float(2**53 + 3)) # Incorrect
pp(float(2**53 + 4)) # Correct
import decimal
pp(decimal.getcontext())
from decimal import Decimal
pp(Decimal(7))
pp(Decimal(0.8))
pp(Decimal(0.8) - Decimal(0.7))
pp(Decimal("0.8") - Decimal("0.7")
) # Works like a charm perfect for usage no floating point issue
def cmb(a, b):
numerator = fc(a)
denominator = fc((a - b)) * fc(b)
return int(numerator / denominator)
from math import factorial as fc a, b = map(int, input().split()) print((fc(a) // (fc(b) * fc(a - b))))
# ↑ ↑ 【k-1:仕切りを置く候補】【i-1:仕切りの数】
# 赤いボールを一列に並べる => R R
# 赤いボールの左端・間・右端の中からi箇所選び､そこに青いボールのセットを置く => R R [n=5]
# ↑ ↑ ↑ [n-k+1:Rの間の数] [このうちi個を選ぶ]
from math import factorial as fc
MOD = 10**9 + 7
n, k = map(int, input().split())
for i in range(1, k + 1):
if n - k + 1 < i: # <=ここで弾かないとRE
print(0)
continue
b = fc(n - k + 1) // fc(i) // fc(n - k + 1 - i)
r = fc(k - 1) // fc(i - 1) // fc(k - 1 - (i - 1))
print(b % MOD * r % MOD)
# 2019/06/29 だめだったやつ
'''
import re
from itertools import permutations
n,k=map(int,input().split())
s=list('1'*k+'0'*(n-k))
pre=0
S=set(permutations(s))
for i in range(1,k+1):
pat=r'1'*k
"""
Author:Ashwini Chaudhary
Link:http://projecteuler.net/problem=34
lang:python
"""
from math import factorial as fc
summ=0
for x in xrange(11,999999):
st=str(x)
if x==sum(fc(int(i)) for i in st):
summ+=x
print summ
def solution2():
from math import factorial as fc
print(sum(map(int, str(fc(100)))))