




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):

				def count_of_possible_combinations(lowerCamelCase ) -> int:
								if target < 0:
												return 0
								if target == 0:
												return 1
								return sum(count_of_possible_combinations(target - item ) for item in array )

				return count_of_possible_combinations(lowerCamelCase )




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):

				def count_of_possible_combinations_with_dp_array(
				    lowerCamelCase						,  lowerCamelCase ) -> int:
								if target < 0:
												return 0
								if target == 0:
												return 1
								if dp_array[target] != -1:
												return dp_array[target]
								__magic_name__						:						str										=sum(
								    count_of_possible_combinations_with_dp_array(target - item						,  lowerCamelCase )
								    for item in array )
								__magic_name__						:						Optional[Any]										=answer
								return answer

				__magic_name__						:						Optional[int]										=[-1] * (target + 1)
				return count_of_possible_combinations_with_dp_array(lowerCamelCase						,  lowerCamelCase )




def 		lowerCAmelCase_ (						lowerCamelCase						,  lowerCamelCase						,  lowerCamelCase ):
				__magic_name__						:						List[Any]										=[0] * (target + 1)
				__magic_name__						:						Dict										=1

				for i in range(1						,  target + 1 ):
								for j in range(lowerCamelCase ):
												if i - array[j] >= 0:
																dp_array[i] += dp_array[i - array[j]]

				return dp_array[target]


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							UpperCAmelCase_		:					Tuple          =  3
							UpperCAmelCase_		:					Dict          =  5
							UpperCAmelCase_		:					Any          =  [1, 2, 5]
							print(combination_sum_iv(n, array, target))











def  SCREAMING_SNAKE_CASE				(      snake_case						,   snake_case							)		->    bool:
		__lowercase											=     len(snake_case							) + 1
		__lowercase											=     len(snake_case							) + 1

		# dp is a 2d matrix where dp[i][j] denotes whether prefix string of
		# length i of input_string matches with prefix string of length j of
		# given pattern.
		# "dp" stands for dynamic programming.
		__lowercase											=     [[0 for i in range(snake_case							)] for j in range(snake_case							)]

		# since string of zero length match pattern of zero length
		__lowercase											=     1

		# since pattern of zero length will never match with string of non-zero length
		for i in range(1						,   snake_case							):
				__lowercase											=     0

		# since string of zero length will match with pattern where there
		# is at least one * alternatively
		for j in range(1						,   snake_case							):
				__lowercase											=     dp[0][j - 2] if pattern[j - 1] == '*' else 0

		# now using bottom-up approach to find for all remaining lengths
		for i in range(1						,   snake_case							):
				for j in range(1						,   snake_case							):
						if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
								__lowercase											=     dp[i - 1][j - 1]

						elif pattern[j - 1] == "*":
								if dp[i][j - 2] == 1:
										__lowercase											=     1
								elif pattern[j - 2] in (input_string[i - 1], "."):
										__lowercase											=     dp[i - 1][j]
								else:
										__lowercase											=     0
						else:
								__lowercase											=     0

		return bool(dp[-1][-1]							)


if __name__ == "__main__":
		import doctest

		doctest.testmod()
		# inputing the strings
		# input_string = input("input a string :")
		# pattern = input("input a pattern :")

		SCREAMING_SNAKE_CASE_   :      Any			=   '''aab'''
		SCREAMING_SNAKE_CASE_   :      str			=   '''c*a*b'''

		# using function to check whether given string matches the given pattern
		if match_pattern(input_string, pattern):
				print(F"""{input_string} matches the given pattern {pattern}""")
		else:
				print(F"""{input_string} does not match with the given pattern {pattern}""")




