


"""simple docstring"""
from __future__ import annotations

from abc import abstractmethod
from collections.abc import Iterable
from typing import Generic, Protocol, TypeVar



class      _UpperCAmelCase					(				__snake_case							):






		'''simple docstring'''

		@abstractmethod
		def __lt__(self							,			a_   ):





			'''simple docstring'''

			pass



		@abstractmethod
		def __gt__(self							,			a_   ):





			'''simple docstring'''

			pass



		@abstractmethod
		def __eq__(self							,			a_   ):





			'''simple docstring'''

			pass

SCREAMING_SNAKE_CASE					:       List[Any]							   =							TypeVar("""T""", bound=Comparable)



class      _UpperCAmelCase					(				Generic[T]							):






		'''simple docstring'''

		def __init__(self   ):





			'''simple docstring'''

			__snake_case      :		list[T]         =							[]
			__snake_case      :		int         =							0



		def __repr__(self   ):





			'''simple docstring'''

			return str(self.h   )



		def 							SCREAMING_SNAKE_CASE    (self							,			a_   ):





			'''simple docstring'''

			if child_idx > 0:
				return (child_idx - 1) // 2
			return None



		def 							SCREAMING_SNAKE_CASE    (self							,			a_   ):





			'''simple docstring'''

			__snake_case      :		str         =							2 * parent_idx + 1
			if left_child_index < self.heap_size:
				return left_child_index
			return None



		def 							SCREAMING_SNAKE_CASE    (self							,			a_   ):





			'''simple docstring'''

			__snake_case      :		Tuple         =							2 * parent_idx + 2
			if right_child_index < self.heap_size:
				return right_child_index
			return None



		def 							SCREAMING_SNAKE_CASE    (self							,			a_   ):





			'''simple docstring'''

			if index < self.heap_size:
				__snake_case      :		int         =							index
				__snake_case      :		Union[str, Any]         =							self.left_child_idx(a_   )
				__snake_case      :		int         =							self.right_child_idx(a_   )
				# check which child is larger than its parent
				if left_child is not None and self.h[left_child] > self.h[violation]:
					__snake_case      :		int         =							left_child
				if right_child is not None and self.h[right_child] > self.h[violation]:
					__snake_case      :		Optional[Any]         =							right_child
				# if violation indeed exists
				if violation != index:
					# swap to fix the violation
					__snake_case      ,				__snake_case      :		str         =							self.h[index], self.h[violation]
					# fix the subsequent violation recursively if any
					self.max_heapify(a_   )



		def 							SCREAMING_SNAKE_CASE    (self							,			a_   ):





			'''simple docstring'''

			__snake_case      :		int         =							list(a_   )
			__snake_case      :		Optional[Any]         =							len(self.h   )
			if self.heap_size > 1:
				# max_heapify from right to left but exclude leaves (last level)
				for i in range(self.heap_size // 2 - 1							,			-1							,			-1   ):
					self.max_heapify(a_   )



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			if self.heap_size >= 2:
				__snake_case      :		Optional[int]         =							self.h[0]
				__snake_case      :		Tuple         =							self.h.pop(-1   )
				self.heap_size -= 1
				self.max_heapify(0   )
				return me
			elif self.heap_size == 1:
				self.heap_size -= 1
				return self.h.pop(-1   )
			else:
				raise Exception('''Empty heap'''   )



		def 							SCREAMING_SNAKE_CASE    (self							,			a_   ):





			'''simple docstring'''

			self.h.append(a_   )
			__snake_case      :		Optional[int]         =							(self.heap_size - 1) // 2
			self.heap_size += 1
			while idx >= 0:
				self.max_heapify(a_   )
				__snake_case      :		int         =							(idx - 1) // 2



		def 							SCREAMING_SNAKE_CASE    (self   ):





			'''simple docstring'''

			__snake_case      :		Optional[Any]         =							self.heap_size
			for j in range(size - 1							,			0							,			-1   ):
				__snake_case      ,				__snake_case      :		Optional[int]         =							self.h[j], self.h[0]
				self.heap_size -= 1
				self.max_heapify(0   )
			__snake_case      :		str         =							size


if __name__ == "__main__":
			import doctest

			# run doc test
			doctest.testmod()

			# demo
			for unsorted in [
			    [0],
			    [2],
			    [3, 5],
			    [5, 3],
			    [5, 5],
			    [0, 0, 0, 0],
			    [1, 1, 1, 1],
			    [2, 2, 3, 5],
			    [0, 2, 2, 3, 5],
			    [2, 5, 3, 0, 2, 3, 0, 3],
			    [6, 1, 2, 7, 9, 3, 4, 5, 10, 8],
			    [103, 9, 1, 7, 11, 15, 25, 201, 209, 107, 5],
			    [-45, -2, -5],
			]:
						print(F'unsorted array: {unsorted}')

						SCREAMING_SNAKE_CASE					:       Heap[int]							   =							Heap()
						heap.build_max_heap(unsorted)
						print(F'after build heap: {heap}')

						print(F'max value: {heap.extract_max()}')
						print(F'after max value removed: {heap}')

						heap.insert(100)
						print(F'after new value 100 inserted: {heap}')

						heap.heap_sort()
						print(F'heap-sorted array: {heap}\n')













'''simple docstring'''







import re






def  lowerCAmelCase__		(					a_  :     Optional[int]			)   -> Optional[Any]:
       def docstring_decorator(a_  :     Dict			):
              UpperCAmelCase__	:   Optional[int]												=	fn.__doc__
              UpperCAmelCase__	:   Dict												=	func_doc.split('''\n'''			)
              UpperCAmelCase__	:   Any												=	0
              while i < len(a_			) and re.search(r'''^\s*Examples?:\s*$'''			,						lines[i]			) is None:
                     i += 1
              if i < len(a_			):
                     UpperCAmelCase__	:   List[Any]												=	example_docstring
                     UpperCAmelCase__	:   int												=	'''\n'''.join(a_			)
              else:
                     raise ValueError(
                         f"""The function {fn} should have an empty 'Examples:' in its docstring as placeholder, """
                         f"""current docstring is:\n{func_doc}"""			)
              UpperCAmelCase__	:   Any												=	func_doc
              return fn

       return docstring_decorator