






def _UpperCAmelCase   (	a						:	str  ,					a						:	str ):
							snake_case__	  =       len(a )
							snake_case__	  =       []
							for i in range(len(a ) - pat_len + 1 ):
														snake_case__	  =       True
														for j in range(a ):
																					if s[i + j] != pattern[j]:
																												snake_case__	  =       False
																												break
														if match_found:
																					position.append(a )
							return position


if __name__ == "__main__":
	assert naive_pattern_search("""ABCDEFG""", """DE""") == [3]
	print(naive_pattern_search("""ABAAABCDBBABCDDEBCABC""", """ABC"""))








def _UpperCAmelCase   (	a						:	int  ,					a						:	Optional[Any] ):
							# "extended trapezoidal rule"
							# int(f) = dx/2 * (f1 + 2f2 + ... + fn)
							snake_case__	  =       (boundary[1] - boundary[0]) / steps
							snake_case__	  =       boundary[0]
							snake_case__	  =       boundary[1]
							snake_case__	  =       make_points(a  ,					a  ,					a )
							snake_case__	  =       0.0
							y += (h / 2.0) * f(a )
							for i in x_i:
														# print(i)
														y += h * f(a )
							y += (h / 2.0) * f(a )
							return y

def _UpperCAmelCase   (	a						:	Dict  ,					a						:	Union[str, Any]  ,					a						:	Union[str, Any] ):
							snake_case__	  =       a + h
							while x < (b - h):
														yield x
														snake_case__	  =       x + h

def _UpperCAmelCase   (	a						:	Any ):  # enter your function here
							snake_case__	  =       (x - 0) * (x - 0)
							return y

def _UpperCAmelCase   (	):
							snake_case__	  =       0.0  # Lower bound of integration
							snake_case__	  =       1.0  # Upper bound of integration
							snake_case__	  =       10.0  # define number of steps or resolution
							snake_case__	  =       [a, b]  # define boundary of integration
							snake_case__	  =       method_a(a  ,					a )
							print(F'''y = {y}''' )


if __name__ == "__main__":
	main()
