






'''simple docstring'''



def  __UpperCAmelCase						(					SCREAMING_SNAKE_CASE__:						list     )	->      Any:

   """simple docstring"""



   if len(__a     ) < 2:
      return collection

   def circle_sort_util(SCREAMING_SNAKE_CASE__:						list,       SCREAMING_SNAKE_CASE__:						int,       SCREAMING_SNAKE_CASE__:						int     ) -> bool:
      __a					  =     False

      if low == high:
         return swapped

      __a					  =     low
      __a					  =     high

      while left < right:
         if collection[left] > collection[right]:
            __a					  =     (
                collection[right],
                collection[left],
            )
            __a					  =     True

         left += 1
         right -= 1

      if left == right and collection[left] > collection[right + 1]:
         __a					  =     (
             collection[right + 1],
             collection[left],
         )

         __a					  =     True

      __a					  =     low + int((high - low) / 2     )
      __a					  =     circle_sort_util(__a,       __a,       __a     )
      __a					  =     circle_sort_util(__a,       mid + 1,       __a     )

      return swapped or left_swap or right_swap

   __a					  =     True

   while is_not_sorted is True:
      __a					  =     circle_sort_util(__a,       0,       len(__a     ) - 1     )

   return collection


if __name__ == "__main__":
 __UpperCamelCase   :							Any         =   input("""Enter numbers separated by a comma:\n""").strip()
 __UpperCamelCase   :							int         =   [int(item) for item in user_input.split(""",""")]
 print(circle_sort(unsorted))




"""simple docstring"""







import numpy as np
from matplotlib import pyplot as plt
from sklearn.datasets import load_iris
from sklearn.metrics import ConfusionMatrixDisplay
from sklearn.model_selection import train_test_split
from xgboost import XGBClassifier

def     UpperCAmelCase_					(				__a   :			dict						):




			'''simple docstring'''



			return (data["data"], data["target"])

def     UpperCAmelCase_					(				__a   :			np.ndarray      ,							__a   :			np.ndarray						):




			'''simple docstring'''



			_lowerCamelCase					:					Dict	       =    XGBClassifier()
			classifier.fit(__a      ,							__a						)
			return classifier

def     UpperCAmelCase_					(				):




			'''simple docstring'''



			_lowerCamelCase					:					List[str]	       =    load_iris()
			_lowerCamelCase       ,							_lowerCamelCase					:					Optional[Any]	       =    data_handling(__a						)
			_lowerCamelCase       ,							_lowerCamelCase       ,							_lowerCamelCase       ,							_lowerCamelCase					:					int	       =    train_test_split(
			    __a      ,							__a      ,							test_size=0.2_5						)

			_lowerCamelCase					:					Optional[Any]	       =    iris['target_names']

			# Create an XGBoost Classifier from the training data
			_lowerCamelCase					:					Tuple	       =    xgboost(__a      ,							__a						)

			# Display the confusion matrix of the classifier with both training and test sets
			ConfusionMatrixDisplay.from_estimator(
			    __a      ,							__a      ,							__a      ,							display_labels=__a      ,							cmap='Blues'      ,							normalize='true'      ,							)
			plt.title('Normalized Confusion Matrix - IRIS Dataset'						)
			plt.show()


if __name__ == "__main__":
	import doctest

	doctest.testmod(verbose=True)
	main()





