
from collections import defaultdict




class      __A:

  """simple docstring"""







  def __init__(self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       UpperCamelCase__				=    total  # total no of tasks (N)

       # DP table will have a dimension of (2^M)*N
       # initially all values are set to -1
       UpperCamelCase__				=    [
           [-1 for i in range(total + 1						)] for j in range(2 ** len(SCREAMING_SNAKE_CASE_						)						)
       ]

       UpperCamelCase__				=    defaultdict(SCREAMING_SNAKE_CASE_						)  # stores the list of persons for each task

       # final_mask is used to check if all persons are included by setting all bits
       # to 1
       UpperCamelCase__				=    (1 << len(SCREAMING_SNAKE_CASE_						)) - 1







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_	,      SCREAMING_SNAKE_CASE_						):
       # if mask == self.finalmask all persons are distributed tasks, return 1
       if mask == self.final_mask:
            return 1

       # if not everyone gets the task and no more tasks are available, return 0
       if task_no > self.total_tasks:
            return 0

       # if case already considered
       if self.dp[mask][task_no] != -1:
            return self.dp[mask][task_no]

       # Number of ways when we don't this task in the arrangement
       UpperCamelCase__				=    self.count_ways_until(SCREAMING_SNAKE_CASE_	,      task_no + 1						)

       # now assign the tasks one by one to all possible persons and recursively
       # assign for the remaining tasks.
       if task_no in self.task:
            for p in self.task[task_no]:
                 # if p is already given a task
                 if mask & (1 << p):
                      continue

                 # assign this task to p and change the mask value. And recursively
                 # assign tasks with the new mask value.
                 total_ways_util += self.count_ways_until(mask | (1 << p)	,      task_no + 1						)

        # save the value.
       UpperCamelCase__				=    total_ways_util

       return self.dp[mask][task_no]







  def 	UpperCAmelCase_ (self	,      SCREAMING_SNAKE_CASE_						):
       # Store the list of persons for each task
       for i in range(len(SCREAMING_SNAKE_CASE_						)						):
            for j in task_performed[i]:
                 self.task[j].append(SCREAMING_SNAKE_CASE_						)

        # call the function to fill the DP table, final answer is stored in dp[0][1]
       return self.count_ways_until(0	,      1						)


if __name__ == "__main__":
    lowerCamelCase_						     =					5  # total no of tasks (the value of N)

    # the list of tasks that can be done by M persons.
    lowerCamelCase_						     =					[[1, 3, 4], [1, 2, 5], [3, 4]]
    print(
        AssignmentUsingBitmask(task_performed, total_tasks).count_no_of_ways(
            task_performed
        )
    )







import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.metrics import mean_absolute_error, mean_squared_error
from sklearn.model_selection import train_test_split
from xgboost import XGBRegressor






def 						__magic_name__			(   __a      :	dict						):



     '''simple docstring'''




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






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



     '''simple docstring'''




     UpperCamelCase__				=    XGBRegressor(verbosity=0	,		random_state=42						)
     xgb.fit(__a	,		__a						)
     # Predict target for test data
     UpperCamelCase__				=    xgb.predict(__a						)
     UpperCamelCase__				=    predictions.reshape(len(__a						)	,		1						)
     return predictions






def 						__magic_name__			(   ):



     '''simple docstring'''




     UpperCamelCase__				=    fetch_california_housing()
     UpperCamelCase__		,	UpperCamelCase__				=    data_handling(__a						)
     UpperCamelCase__		,	UpperCamelCase__		,	UpperCamelCase__		,	UpperCamelCase__				=    train_test_split(
         __a	,		__a	,		test_size=0.25	,		random_state=1						)
     UpperCamelCase__				=    xgboost(__a	,		__a	,		__a						)
     # Error printing
     print(f"Mean Absolute Error : {mean_absolute_error(__a	,		__a						)}"						)
     print(f"Mean Square Error  : {mean_squared_error(__a	,		__a						)}"						)


if __name__ == "__main__":
    import doctest

    doctest.testmod(verbose=True)
    main()





