






'''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 							snake_case					(     a_							: dict	)       ->				tuple:





      """simple docstring"""

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



def 							snake_case					(     a_							: np.ndarray    ,   a_							: np.ndarray	)       ->				XGBClassifier:





      """simple docstring"""

      UpperCamelCase_				:   Optional[Any]					    =							XGBClassifier()
      classifier.fit(a_    ,   a_	)
      return classifier



def 							snake_case					(     )       ->				None:





      """simple docstring"""

      UpperCamelCase_				:   int					    =							load_iris()
      UpperCamelCase_    ,			UpperCamelCase_				:   Any					    =							data_handling(a_	)
      UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_    ,			UpperCamelCase_				:   Optional[int]					    =							train_test_split(
          a_    ,   a_    ,   test_size=0.25	)

      UpperCamelCase_				:   str					    =							iris["""target_names"""]

      # Create an XGBoost Classifier from the training data
      UpperCamelCase_				:   Union[str, Any]					    =							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()














'''simple docstring'''

from itertools import count



def 							snake_case					(     a_							: int = 50	)       ->				int:





      """simple docstring"""

      UpperCamelCase_				:   int					    =							[1] * min_block_length

      for n in count(a_	):
            fill_count_functions.append(1	)

            for block_length in range(a_    ,   n + 1	):
                  for block_start in range(n - block_length	):
                        fill_count_functions[n] += fill_count_functions[
                            n - block_start - block_length - 1
                        ]

                  fill_count_functions[n] += 1

            if fill_count_functions[n] > 1_000_000:
                  break

      return n


if __name__ == "__main__":
      print(f"{solution() = }")






