


from math import factorial






def   _lowercase(					__a				:						int    ,     __a				:						int    ,     __a				:						float     ):
							if successes > trials:
														raise ValueError('successes must be lower or equal to trials'     )
							if trials < 0 or successes < 0:
														raise ValueError('the function is defined for non-negative integers'     )
							if not isinstance(__a    ,     __a     ) or not isinstance(__a    ,     __a     ):
														raise ValueError('the function is defined for non-negative integers'     )
							if not 0 < prob < 1:
														raise ValueError('prob has to be in range of 1 - 0'     )
							a__      =(prob**successes) * ((1 - prob) ** (trials - successes))
							# Calculate the binomial coefficient: n! / k!(n-k)!
							a__      =float(factorial(__a     )     )
							coefficient /= factorial(__a     ) * factorial(trials - successes     )
							return probability * coefficient


if __name__ == "__main__":
	from doctest import testmod

	testmod()
	print('Probability of 2 successes out of 4 trails')
	print('with probability of 0.75 is:', end=' ')
	print(binomial_distribution(2, 4, 0.75))









"""simple docstring"""
def 							snake_case (  A__		):
			UpperCAmelCase_	:					int     	=   [0 for i in range(len(A__		)		)]

			# initialize interval's left pointer and right pointer
			UpperCAmelCase_	,      UpperCAmelCase_	:					Optional[int]     	=   0, 0

			for i in range(1      ,len(A__		)		):
						# case when current index is inside the interval
						if i <= right_pointer:
									UpperCAmelCase_	:					Any     	=   min(right_pointer - i + 1      ,z_result[i - left_pointer]		)
									UpperCAmelCase_	:					Union[str, Any]     	=   min_edge

						while go_next(A__      ,A__      ,A__		):
									z_result[i] += 1

						# if new index's result gives us more right interval,
						# we've to update left_pointer and right_pointer
						if i + z_result[i] - 1 > right_pointer:
									UpperCAmelCase_	,      UpperCAmelCase_	:					Union[str, Any]     	=   i, i + z_result[i] - 1

			return z_result

def 							snake_case (  A__      ,A__      ,A__		):
			return i + z_result[i] < len(A__		) and s[z_result[i]] == s[i + z_result[i]]

def 							snake_case (  A__      ,A__		):
			UpperCAmelCase_	:					Optional[int]     	=   0
			# concatenate 'pattern' and 'input_str' and call z_function
			# with concatenated string
			UpperCAmelCase_	:					Tuple     	=   z_function(pattern + input_str		)

			for val in z_result:
						# if value is greater then length of the pattern string
						# that means this index is starting position of substring
						# which is equal to pattern string
						if val >= len(A__		):
									answer += 1

			return answer


if __name__ == "__main__":
			import doctest

			doctest.testmod()



