






def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  Union[str, Any]:





						"""simple docstring"""



						_UpperCAmelCase									=			(boundary[1] - boundary[0]) / steps
						_UpperCAmelCase									=			boundary[0]
						_UpperCAmelCase									=			boundary[1]
						_UpperCAmelCase									=			make_points(__lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	)
						_UpperCAmelCase									=			0.0
						y += (h / 2.0) * f(__lowerCAmelCase	)
						for i in x_i:
												# print(i)
												y += h * f(__lowerCAmelCase	)
						y += (h / 2.0) * f(__lowerCAmelCase	)
						return y


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase ,		__lowerCAmelCase	)->  Optional[Any]:





						"""simple docstring"""



						_UpperCAmelCase									=			a + h
						while x < (b - h):
												yield x
												_UpperCAmelCase									=			x + h


def __A    (      __lowerCAmelCase	)->  Optional[Any]:  # enter your function here





						"""simple docstring"""



						_UpperCAmelCase									=			(x - 0) * (x - 0)
						return y


def __A    (      )->  int:





						"""simple docstring"""



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


if __name__ == "__main__":
		main()








from __future__ import annotations

from itertools import permutations
from random import randint
from timeit import repeat


def __A    (      )->  tuple[list[int], int]:





						"""simple docstring"""



						_UpperCAmelCase									=			[randint(-1_000 ,		1_000	) for i in range(10	)]
						_UpperCAmelCase									=			randint(-5_000 ,		5_000	)
						return (arr, r)


_a      	=  make_dataset()


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  tuple[int, ...]:





						"""simple docstring"""



						for triplet in permutations(__lowerCAmelCase ,		3	):
												if sum(__lowerCAmelCase	) == target:
																		return tuple(sorted(__lowerCAmelCase	)	)
						return (0, 0, 0)


def __A    (      __lowerCAmelCase ,		__lowerCAmelCase	)->  tuple[int, int, int]:





						"""simple docstring"""



						arr.sort()
						_UpperCAmelCase									=			len(__lowerCAmelCase	)
						for i in range(n - 1	):
												_UpperCAmelCase					, _UpperCAmelCase									=			i + 1, n - 1
												while left < right:
																		if arr[i] + arr[left] + arr[right] == target:
																								return (arr[i], arr[left], arr[right])
																		elif arr[i] + arr[left] + arr[right] < target:
																								left += 1
																		elif arr[i] + arr[left] + arr[right] > target:
																								right -= 1
						return (0, 0, 0)


def __A    (      )->  tuple[float, float]:





						"""simple docstring"""



						_UpperCAmelCase									=			'\nfrom __main__ import dataset, triplet_sum1, triplet_sum2\n'
						_UpperCAmelCase									=			'\ntriplet_sum1(*dataset)\n'
						_UpperCAmelCase									=			'\ntriplet_sum2(*dataset)\n'
						_UpperCAmelCase									=			repeat(setup=__lowerCAmelCase ,		stmt=__lowerCAmelCase ,		repeat=5 ,		number=10_000	)
						_UpperCAmelCase									=			repeat(setup=__lowerCAmelCase ,		stmt=__lowerCAmelCase ,		repeat=5 ,		number=10_000	)
						return (min(__lowerCAmelCase	), min(__lowerCAmelCase	))


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

		testmod()
		_a      	=  solution_times()
		print(F'''The time for naive implementation is {times[0]}.''')
		print(F'''The time for optimized implementation is {times[1]}.''')
