

import numpy as np
from PIL import Image






def 					lowerCamelCase_     (   UpperCAmelCase_							:     np.ndarray							,       UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     int	)						->				np.ndarray:




	'''simple docstring'''




	_UpperCamelCase   :		Any			=						np.array(UpperCAmelCase_	)
	if arr.shape[0] != arr.shape[1]:
		raise ValueError('The input array is not a square matrix'	)
	_UpperCamelCase   :		List[str]			=						0
	_UpperCamelCase   :		str			=						0
	_UpperCamelCase   :		int			=						0
	_UpperCamelCase   :		Tuple			=						0

	# compute the shape of the output matrix
	_UpperCamelCase   :		Optional[Any]			=						(arr.shape[0] - size) // stride + 1
	# initialize the output matrix with zeros of shape maxpool_shape
	_UpperCamelCase   :		List[Any]			=						np.zeros((maxpool_shape, maxpool_shape)	)

	while i < arr.shape[0]:
		if i + size > arr.shape[0]:
			# if the end of the matrix is reached, break
			break
		while j < arr.shape[1]:
			# if the end of the matrix is reached, break
			if j + size > arr.shape[1]:
				break
			# compute the maximum of the pooling matrix
			_UpperCamelCase   :		Dict			=						np.max(arr[i : i + size, j : j + size]	)
			# shift the pooling matrix by stride of column pixels
			j += stride
			mat_j += 1

		# shift the pooling matrix by stride of row pixels
		i += stride
		mat_i += 1

		# reset the column index to 0
		_UpperCamelCase   :		int			=						0
		_UpperCamelCase   :		Optional[Any]			=						0

	return updated_arr






def 					lowerCamelCase_     (   UpperCAmelCase_							:     np.ndarray							,       UpperCAmelCase_							:     int							,       UpperCAmelCase_							:     int	)						->				np.ndarray:




	'''simple docstring'''




	_UpperCamelCase   :		Tuple			=						np.array(UpperCAmelCase_	)
	if arr.shape[0] != arr.shape[1]:
		raise ValueError('The input array is not a square matrix'	)
	_UpperCamelCase   :		Any			=						0
	_UpperCamelCase   :		List[Any]			=						0
	_UpperCamelCase   :		Optional[int]			=						0
	_UpperCamelCase   :		Optional[Any]			=						0

	# compute the shape of the output matrix
	_UpperCamelCase   :		List[Any]			=						(arr.shape[0] - size) // stride + 1
	# initialize the output matrix with zeros of shape avgpool_shape
	_UpperCamelCase   :		List[str]			=						np.zeros((avgpool_shape, avgpool_shape)	)

	while i < arr.shape[0]:
		# if the end of the matrix is reached, break
		if i + size > arr.shape[0]:
			break
		while j < arr.shape[1]:
			# if the end of the matrix is reached, break
			if j + size > arr.shape[1]:
				break
			# compute the average of the pooling matrix
			_UpperCamelCase   :		Any			=						int(np.average(arr[i : i + size, j : j + size]	)	)
			# shift the pooling matrix by stride of column pixels
			j += stride
			mat_j += 1

		# shift the pooling matrix by stride of row pixels
		i += stride
		mat_i += 1
		# reset the column index to 0
		_UpperCamelCase   :		Optional[int]			=						0
		_UpperCamelCase   :		Tuple			=						0

	return updated_arr


# Main Function
if __name__ == "__main__":
							from doctest import testmod

							testmod(name="""avgpooling""", verbose=True)

							# Loading the image
							lowerCAmelCase__								=		Image.open("""path_to_image""")

							# Converting the image to numpy array and maxpooling, displaying the result
							# Ensure that the image is a square matrix

							Image.fromarray(maxpooling(np.array(image), size=3, stride=2)).show()

							# Converting the image to numpy array and averagepooling, displaying the result
							# Ensure that the image is a square matrix

							Image.fromarray(avgpooling(np.array(image), size=3, stride=2)).show()







import functools






def 					lowerCamelCase_     (							UpperCAmelCase_							:     list[int]							,       UpperCAmelCase_							:     list[int]	)						->				int:




	'''simple docstring'''




	if not isinstance(UpperCAmelCase_							,       UpperCAmelCase_	) or not all(isinstance(UpperCAmelCase_							,       UpperCAmelCase_	) for day in days	):
		raise ValueError('The parameter days should be a list of integers'	)

	if len(UpperCAmelCase_	) != 3 or not all(isinstance(UpperCAmelCase_							,       UpperCAmelCase_	) for cost in costs	):
		raise ValueError('The parameter costs should be a list of three integers'	)

	if len(UpperCAmelCase_	) == 0:
		return 0

	if min(UpperCAmelCase_	) <= 0:
		raise ValueError('All days elements should be greater than 0'	)

	if max(UpperCAmelCase_	) >= 3_6_6:
		raise ValueError('All days elements should be less than 366'	)

	_UpperCamelCase   :		Union[str, Any]			=						set(UpperCAmelCase_	)

	@functools.cache
	def dynamic_programming(UpperCAmelCase_							:     int	) -> int:
		if index > 3_6_5:
			return 0

		if index not in days_set:
			return dynamic_programming(index + 1	)

		return min(
		    costs[0] + dynamic_programming(index + 1	)							,       costs[1] + dynamic_programming(index + 7	)							,       costs[2] + dynamic_programming(index + 3_0	)							,       )

	return dynamic_programming(1	)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




