


from __future__ import annotations

import unittest
from collections.abc import Iterator

class   A__							:




						def __init__(				self    :					List[Any] ,			_a    :					int ,			_a    :					Node | None     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =label
										_SCREAMING_SNAKE_CASE	     =parent
										_SCREAMING_SNAKE_CASE	     =None
										_SCREAMING_SNAKE_CASE	     =None

class   A__							:




						def __init__(				self    :					str     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =None




						def 							__UpperCamelCase (				self    :					Any     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =None




						def 							__UpperCamelCase (				self    :					Optional[Any]     )							->   bool:


										"""simple docstring"""





										return self.root is None




						def 							__UpperCamelCase (				self    :					Any ,			_a    :					int     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._put(self.root ,			_a     )




						def 							__UpperCamelCase (				self    :					int ,			_a    :					Node | None ,			_a    :					int ,			_a    :					Node | None = None     )							->   Node:


										"""simple docstring"""





										if node is None:
														_SCREAMING_SNAKE_CASE	     =Node(_a ,			_a     )
										else:
														if label < node.label:
																		_SCREAMING_SNAKE_CASE	     =self._put(node.left ,			_a ,			_a     )
														elif label > node.label:
																		_SCREAMING_SNAKE_CASE	     =self._put(node.right ,			_a ,			_a     )
														else:
																		_SCREAMING_SNAKE_CASE	     =f"Node with label {label} already exists"
																		raise Exception(_a     )

										return node




						def 							__UpperCamelCase (				self    :					Any ,			_a    :					int     )							->   Node:


										"""simple docstring"""





										return self._search(self.root ,			_a     )




						def 							__UpperCamelCase (				self    :					Any ,			_a    :					Node | None ,			_a    :					int     )							->   Node:


										"""simple docstring"""





										if node is None:
														_SCREAMING_SNAKE_CASE	     =f"Node with label {label} does not exist"
														raise Exception(_a     )
										else:
														if label < node.label:
																		_SCREAMING_SNAKE_CASE	     =self._search(node.left ,			_a     )
														elif label > node.label:
																		_SCREAMING_SNAKE_CASE	     =self._search(node.right ,			_a     )

										return node




						def 							__UpperCamelCase (				self    :					Optional[int] ,			_a    :					int     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self.search(_a     )
										if node.right and node.left:
														_SCREAMING_SNAKE_CASE	     =self._get_lowest_node(node.right     )
														_SCREAMING_SNAKE_CASE	     =node.left
														_SCREAMING_SNAKE_CASE	     =node.right
														_SCREAMING_SNAKE_CASE	     =lowest_node
														if node.right:
																		_SCREAMING_SNAKE_CASE	     =lowest_node
														self._reassign_nodes(_a ,			_a     )
										elif not node.right and node.left:
														self._reassign_nodes(_a ,			node.left     )
										elif node.right and not node.left:
														self._reassign_nodes(_a ,			node.right     )
										else:
														self._reassign_nodes(_a ,			_a     )




						def 							__UpperCamelCase (				self    :					List[str] ,			_a    :					Node ,			_a    :					Node | None     )							->   None:


										"""simple docstring"""





										if new_children:
														_SCREAMING_SNAKE_CASE	     =node.parent

										if node.parent:
														if node.parent.right == node:
																		_SCREAMING_SNAKE_CASE	     =new_children
														else:
																		_SCREAMING_SNAKE_CASE	     =new_children
										else:
														_SCREAMING_SNAKE_CASE	     =new_children




						def 							__UpperCamelCase (				self    :					Dict ,			_a    :					Node     )							->   Node:


										"""simple docstring"""





										if node.left:
														_SCREAMING_SNAKE_CASE	     =self._get_lowest_node(node.left     )
										else:
														_SCREAMING_SNAKE_CASE	     =node
														self._reassign_nodes(_a ,			node.right     )

										return lowest_node




						def 							__UpperCamelCase (				self    :					Dict ,			_a    :					int     )							->   bool:


										"""simple docstring"""





										try:
														self.search(_a     )
														return True
										except Exception:
														return False




						def 							__UpperCamelCase (				self    :					Union[str, Any]     )							->   int:


										"""simple docstring"""





										if self.root is None:
														raise Exception('''Binary search tree is empty'''     )

										_SCREAMING_SNAKE_CASE	     =self.root
										while node.right is not None:
														_SCREAMING_SNAKE_CASE	     =node.right

										return node.label




						def 							__UpperCamelCase (				self    :					Dict     )							->   int:


										"""simple docstring"""





										if self.root is None:
														raise Exception('''Binary search tree is empty'''     )

										_SCREAMING_SNAKE_CASE	     =self.root
										while node.left is not None:
														_SCREAMING_SNAKE_CASE	     =node.left

										return node.label




						def 							__UpperCamelCase (				self    :					List[Any]     )							->   Iterator[Node]:


										"""simple docstring"""





										return self._inorder_traversal(self.root     )




						def 							__UpperCamelCase (				self    :					Optional[int] ,			_a    :					Node | None     )							->   Iterator[Node]:


										"""simple docstring"""





										if node is not None:
														yield from self._inorder_traversal(node.left     )
														yield node
														yield from self._inorder_traversal(node.right     )




						def 							__UpperCamelCase (				self    :					str     )							->   Iterator[Node]:


										"""simple docstring"""





										return self._preorder_traversal(self.root     )




						def 							__UpperCamelCase (				self    :					Dict ,			_a    :					Node | None     )							->   Iterator[Node]:


										"""simple docstring"""





										if node is not None:
														yield node
														yield from self._preorder_traversal(node.left     )
														yield from self._preorder_traversal(node.right     )

class   A__							(						unittest.TestCase     ):




						@staticmethod
						def 							__UpperCamelCase (				)							->   BinarySearchTree:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =BinarySearchTree()
										t.put(8     )
										t.put(3     )
										t.put(6     )
										t.put(1     )
										t.put(10     )
										t.put(14     )
										t.put(13     )
										t.put(4     )
										t.put(7     )
										t.put(5     )

										return t




						def 							__UpperCamelCase (				self    :					List[Any]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =BinarySearchTree()
										assert t.is_empty()

										t.put(8     )
										assert t.root is not None
										assert t.root.parent is None
										assert t.root.label == 8

										t.put(10     )
										assert t.root.right is not None
										assert t.root.right.parent == t.root
										assert t.root.right.label == 10

										t.put(3     )
										assert t.root.left is not None
										assert t.root.left.parent == t.root
										assert t.root.left.label == 3

										t.put(6     )
										assert t.root.left.right is not None
										assert t.root.left.right.parent == t.root.left
										assert t.root.left.right.label == 6

										t.put(1     )
										assert t.root.left.left is not None
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.left.label == 1

										with self.assertRaises(_a     ):  # noqa: B017
														t.put(1     )




						def 							__UpperCamelCase (				self    :					List[str]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										_SCREAMING_SNAKE_CASE	     =t.search(6     )
										assert node.label == 6

										_SCREAMING_SNAKE_CASE	     =t.search(13     )
										assert node.label == 13

										with self.assertRaises(_a     ):  # noqa: B017
														t.search(2     )




						def 							__UpperCamelCase (				self    :					List[Any]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										t.remove(13     )
										assert t.root is not None
										assert t.root.right is not None
										assert t.root.right.right is not None
										assert t.root.right.right.right is None
										assert t.root.right.right.left is None

										t.remove(7     )
										assert t.root.left is not None
										assert t.root.left.right is not None
										assert t.root.left.right.left is not None
										assert t.root.left.right.right is None
										assert t.root.left.right.left.label == 4

										t.remove(6     )
										assert t.root.left.left is not None
										assert t.root.left.right.right is not None
										assert t.root.left.left.label == 1
										assert t.root.left.right.label == 4
										assert t.root.left.right.right.label == 5
										assert t.root.left.right.left is None
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.right.parent == t.root.left

										t.remove(3     )
										assert t.root is not None
										assert t.root.left.label == 4
										assert t.root.left.right.label == 5
										assert t.root.left.left.label == 1
										assert t.root.left.parent == t.root
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.right.parent == t.root.left

										t.remove(4     )
										assert t.root.left is not None
										assert t.root.left.left is not None
										assert t.root.left.label == 5
										assert t.root.left.right is None
										assert t.root.left.left.label == 1
										assert t.root.left.parent == t.root
										assert t.root.left.left.parent == t.root.left




						def 							__UpperCamelCase (				self    :					Optional[Any]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										t.remove(3     )
										assert t.root is not None
										assert t.root.left is not None
										assert t.root.left.left is not None
										assert t.root.left.right is not None
										assert t.root.left.right.left is not None
										assert t.root.left.right.right is not None
										assert t.root.left.label == 4
										assert t.root.left.right.label == 6
										assert t.root.left.left.label == 1
										assert t.root.left.right.right.label == 7
										assert t.root.left.right.left.label == 5
										assert t.root.left.parent == t.root
										assert t.root.left.right.parent == t.root.left
										assert t.root.left.left.parent == t.root.left
										assert t.root.left.right.left.parent == t.root.left.right




						def 							__UpperCamelCase (				self    :					int     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()
										t.empty()
										assert t.root is None




						def 							__UpperCamelCase (				self    :					Optional[Any]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()
										assert not t.is_empty()

										t.empty()
										assert t.is_empty()




						def 							__UpperCamelCase (				self    :					Optional[Any]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										assert t.exists(6     )
										assert not t.exists(-1     )




						def 							__UpperCamelCase (				self    :					Any     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										assert t.get_max_label() == 14

										t.empty()
										with self.assertRaises(_a     ):  # noqa: B017
														t.get_max_label()




						def 							__UpperCamelCase (				self    :					Optional[Any]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										assert t.get_min_label() == 1

										t.empty()
										with self.assertRaises(_a     ):  # noqa: B017
														t.get_min_label()




						def 							__UpperCamelCase (				self    :					str     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										_SCREAMING_SNAKE_CASE	     =[i.label for i in t.inorder_traversal()]
										assert inorder_traversal_nodes == [1, 3, 4, 5, 6, 7, 8, 10, 13, 14]




						def 							__UpperCamelCase (				self    :					Optional[Any]     )							->   None:


										"""simple docstring"""





										_SCREAMING_SNAKE_CASE	     =self._get_binary_search_tree()

										_SCREAMING_SNAKE_CASE	     =[i.label for i in t.preorder_traversal()]
										assert preorder_traversal_nodes == [8, 3, 1, 6, 4, 5, 7, 10, 14, 13]







def   lowerCamelCase(      ):
				_SCREAMING_SNAKE_CASE	     =BinarySearchTree()
				t.put(8)
				t.put(3)
				t.put(6)
				t.put(1)
				t.put(10)
				t.put(14)
				t.put(13)
				t.put(4)
				t.put(7)
				t.put(5)

				print(
				    '''
            8
           / \\
          3   10
         / \\    \\
        1   6    14
           / \\   /
          4   7 13
           \\
            5
        ''')

				print('''Label 6 exists:'''		,t.exists(6))
				print('''Label 13 exists:'''		,t.exists(13))
				print('''Label -1 exists:'''		,t.exists(-1))
				print('''Label 12 exists:'''		,t.exists(12))

				# Prints all the elements of the list in inorder traversal
				_SCREAMING_SNAKE_CASE	     =[i.label for i in t.inorder_traversal()]
				print('''Inorder traversal:'''		,a__)

				# Prints all the elements of the list in preorder traversal
				_SCREAMING_SNAKE_CASE	     =[i.label for i in t.preorder_traversal()]
				print('''Preorder traversal:'''		,a__)

				print('''Max. label:'''		,t.get_max_label())
				print('''Min. label:'''		,t.get_min_label())

				# Delete elements
				print('''\nDeleting elements 13, 10, 8, 3, 6, 14''')
				print(
				    '''
          4
         / \\
        1   7
             \\
              5
        ''')
				t.remove(13)
				t.remove(10)
				t.remove(8)
				t.remove(3)
				t.remove(6)
				t.remove(14)

				# Prints all the elements of the list in inorder traversal after delete
				_SCREAMING_SNAKE_CASE	     =[i.label for i in t.inorder_traversal()]
				print('''Inorder traversal after delete:'''		,a__)

				# Prints all the elements of the list in preorder traversal after delete
				_SCREAMING_SNAKE_CASE	     =[i.label for i in t.preorder_traversal()]
				print('''Preorder traversal after delete:'''		,a__)

				print('''Max. label:'''		,t.get_max_label())
				print('''Min. label:'''		,t.get_min_label())


if __name__ == "__main__":
							binary_search_tree_example()





import json
import os
from dataclasses import dataclass

import numpy as np
import pyarrow as pa

import datasets
from utils import get_duration


UpperCamelCase__              =						1_0_0_0_0_0_0_0_0_0_0_0
UpperCamelCase__              =						1_0_0_0_0

UpperCamelCase__       , UpperCamelCase__              =						os.path.split(__file__)
UpperCamelCase__              =						os.path.join(RESULTS_BASEPATH, 'results', RESULTS_FILENAME.replace('.py', '.json'))






def 					snake_case					(							A						,   A			)							->							datasets.Dataset:




	'''simple docstring'''


	lowerCamelCase_							:		int							   =							pa.Table.from_pydict({'col': [0] * chunk_size}			)
	lowerCamelCase_							:		List[str]							   =							pa.concat_tables([table] * (num_examples // chunk_size)			)
	return datasets.Dataset(A						,   fingerprint='table_100B'			)


@dataclass
class 				__SCREAMING_SNAKE_CASE							:
					_lowerCamelCase		  = 42
					_lowerCamelCase		  = 42
					_lowerCamelCase		  = 42
					_lowerCamelCase		  = 42

					def 	lowercase_							(				self					):







						'''simple docstring'''




						lowerCamelCase_							:		Optional[Any]							   =							np.random.default_rng(self.seed					)
						lowerCamelCase_							:		Any							   =							rng.integers(low=self.low ,       high=self.high ,       size=self.size					).tolist()

					def __iter__(				self					):







						'''simple docstring'''




						return iter(self._sampled_values					)





					def __len__(				self					):







						'''simple docstring'''




						return self.size






@get_duration
def 					snake_case					(							A			)							->							Optional[Any]:




	'''simple docstring'''


	lowerCamelCase_							:		Union[str, Any]							   =							dataset[0]






@get_duration
def 					snake_case					(							A			)							->							Any:




	'''simple docstring'''


	lowerCamelCase_							:		List[Any]							   =							dataset[-1]






@get_duration
def 					snake_case					(							A			)							->							Optional[Any]:




	'''simple docstring'''


	lowerCamelCase_							:		Tuple							   =							dataset[range(len(A			) // 2						,   len(A			) // 2 + 1024			)]






@get_duration
def 					snake_case					(							A			)							->							str:




	'''simple docstring'''


	lowerCamelCase_							:		List[str]							   =							dataset[RandIter(0						,   len(A			)						,   1024						,   seed=42			)]






def 					snake_case					(							)							->							List[Any]:




	'''simple docstring'''


	lowerCamelCase_							:		Tuple							   =							{'num examples': SPEED_TEST_N_EXAMPLES}
	lowerCamelCase_							:		Optional[int]							   =							(get_first_row, get_last_row, get_batch_of_aaaa_rows, get_batch_of_aaaa_random_rows)
	print('generating dataset'			)
	lowerCamelCase_							:		List[Any]							   =							generate_100B_dataset(num_examples=A						,   chunk_size=A			)
	print('Functions'			)
	for func in functions:
		print(func.__name__			)
		lowerCamelCase_							:		str							   =							func(A			)

	with open(A						,   'wb'			) as f:
		f.write(json.dumps(A			).encode('utf-8'			)			)


if __name__ == "__main__":  # useful to run the profiler
							benchmark_table_100B()
